@langchain/google-genai 0.0.17 → 0.0.18

package/dist/chat_models.cjs

@@ -118,6 +118,12 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "streamUsage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -179,6 +185,7 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             apiVersion: fields?.apiVersion,
             baseUrl: fields?.baseUrl,
         });
+        this.streamUsage = fields?.streamUsage ?? this.streamUsage;
     }
     getLsParams(options) {
         return {
@@ -236,40 +243,67 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
                 .map(([_, value]) => value);
             return { generations, llmOutput: { estimatedTokenUsage: tokenUsage } };
         }
-        const res = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
-            let output;
-            try {
-                output = await this.client.generateContent({
-                    ...parameters,
-                    contents: prompt,
-                });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }
-            catch (e) {
-                // TODO: Improve error handling
-                if (e.message?.includes("400 Bad Request")) {
-                    e.status = 400;
-                }
-                throw e;
-            }
-            return output;
+        const res = await this.completionWithRetry({
+            ...parameters,
+            contents: prompt,
+        });
+        let usageMetadata;
+        if ("usageMetadata" in res.response) {
+            const genAIUsageMetadata = res.response.usageMetadata;
+            usageMetadata = {
+                input_tokens: genAIUsageMetadata.promptTokenCount ?? 0,
+                output_tokens: genAIUsageMetadata.candidatesTokenCount ?? 0,
+                total_tokens: genAIUsageMetadata.totalTokenCount ?? 0,
+            };
+        }
+        const generationResult = (0, common_js_1.mapGenerateContentResultToChatResult)(res.response, {
+            usageMetadata,
         });
-        const generationResult = (0, common_js_1.mapGenerateContentResultToChatResult)(res.response);
         await runManager?.handleLLMNewToken(generationResult.generations[0].text ?? "");
         return generationResult;
     }
     async *_streamResponseChunks(messages, options, runManager) {
         const prompt = (0, common_js_1.convertBaseMessagesToContent)(messages, this._isMultimodalModel);
         const parameters = this.invocationParams(options);
+        const request = {
+            ...parameters,
+            contents: prompt,
+        };
         const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
-            const { stream } = await this.client.generateContentStream({
-                ...parameters,
-                contents: prompt,
-            });
+            const { stream } = await this.client.generateContentStream(request);
             return stream;
         });
+        let usageMetadata;
+        let index = 0;
         for await (const response of stream) {
-            const chunk = (0, common_js_1.convertResponseContentToChatGenerationChunk)(response);
+            if ("usageMetadata" in response &&
+                this.streamUsage !== false &&
+                options.streamUsage !== false) {
+                const genAIUsageMetadata = response.usageMetadata;
+                if (!usageMetadata) {
+                    usageMetadata = {
+                        input_tokens: genAIUsageMetadata.promptTokenCount,
+                        output_tokens: genAIUsageMetadata.candidatesTokenCount,
+                        total_tokens: genAIUsageMetadata.totalTokenCount,
+                    };
+                }
+                else {
+                    // Under the hood, LangChain combines the prompt tokens. Google returns the updated
+                    // total each time, so we need to find the difference between the tokens.
+                    const outputTokenDiff = genAIUsageMetadata.candidatesTokenCount -
+                        usageMetadata.output_tokens;
+                    usageMetadata = {
+                        input_tokens: 0,
+                        output_tokens: outputTokenDiff,
+                        total_tokens: outputTokenDiff,
+                    };
+                }
+            }
+            const chunk = (0, common_js_1.convertResponseContentToChatGenerationChunk)(response, {
+                usageMetadata,
+                index,
+            });
+            index += 1;
             if (!chunk) {
                 continue;
             }
@@ -277,6 +311,21 @@ class ChatGoogleGenerativeAI extends chat_models_1.BaseChatModel {
             await runManager?.handleLLMNewToken(chunk.text ?? "");
         }
     }
+    async completionWithRetry(request, options) {
+        return this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            try {
+                return this.client.generateContent(request);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                // TODO: Improve error handling
+                if (e.message?.includes("400 Bad Request")) {
+                    e.status = 400;
+                }
+                throw e;
+            }
+        });
+    }
     withStructuredOutput(outputSchema, config) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;

package/dist/chat_models.d.ts

@@ -1,4 +1,4 @@
-import { FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GenerateContentRequest, SafetySetting } from "@google/generative-ai";
+import { FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, GenerateContentRequest, SafetySetting, Part as GenerativeAIPart } from "@google/generative-ai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { AIMessageChunk, BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
@@ -13,11 +13,17 @@ export type BaseMessageExamplePair = {
 };
 export interface GoogleGenerativeAIChatCallOptions extends BaseLanguageModelCallOptions {
     tools?: StructuredToolInterface[] | GoogleGenerativeAIFunctionDeclarationsTool[];
+    /**
+     * Whether or not to include usage data, like token counts
+     * in the streamed response chunks.
+     * @default true
+     */
+    streamUsage?: boolean;
 }
 /**
  * An interface defining the input to the ChatGoogleGenerativeAI class.
  */
-export interface GoogleGenerativeAIChatInput extends BaseChatModelParams {
+export interface GoogleGenerativeAIChatInput extends BaseChatModelParams, Pick<GoogleGenerativeAIChatCallOptions, "streamUsage"> {
     /**
      * Model Name to use
      *
@@ -147,6 +153,7 @@ export declare class ChatGoogleGenerativeAI extends BaseChatModel<GoogleGenerati
     safetySettings?: SafetySetting[];
     apiKey?: string;
     streaming: boolean;
+    streamUsage: boolean;
     private client;
     get _isMultimodalModel(): boolean;
     constructor(fields?: GoogleGenerativeAIChatInput);
@@ -157,6 +164,7 @@ export declare class ChatGoogleGenerativeAI extends BaseChatModel<GoogleGenerati
     invocationParams(options?: this["ParsedCallOptions"]): Omit<GenerateContentRequest, "contents">;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     _streamResponseChunks(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    completionWithRetry(request: string | GenerateContentRequest | (string | GenerativeAIPart)[], options?: this["ParsedCallOptions"]): Promise<import("@google/generative-ai").GenerateContentResult>;
     withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
     withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
         raw: BaseMessage;

package/dist/chat_models.js

@@ -115,6 +115,12 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
             writable: true,
             value: false
         });
+        Object.defineProperty(this, "streamUsage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -176,6 +182,7 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
             apiVersion: fields?.apiVersion,
             baseUrl: fields?.baseUrl,
         });
+        this.streamUsage = fields?.streamUsage ?? this.streamUsage;
     }
     getLsParams(options) {
         return {
@@ -233,40 +240,67 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
                 .map(([_, value]) => value);
             return { generations, llmOutput: { estimatedTokenUsage: tokenUsage } };
         }
-        const res = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
-            let output;
-            try {
-                output = await this.client.generateContent({
-                    ...parameters,
-                    contents: prompt,
-                });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }
-            catch (e) {
-                // TODO: Improve error handling
-                if (e.message?.includes("400 Bad Request")) {
-                    e.status = 400;
-                }
-                throw e;
-            }
-            return output;
+        const res = await this.completionWithRetry({
+            ...parameters,
+            contents: prompt,
+        });
+        let usageMetadata;
+        if ("usageMetadata" in res.response) {
+            const genAIUsageMetadata = res.response.usageMetadata;
+            usageMetadata = {
+                input_tokens: genAIUsageMetadata.promptTokenCount ?? 0,
+                output_tokens: genAIUsageMetadata.candidatesTokenCount ?? 0,
+                total_tokens: genAIUsageMetadata.totalTokenCount ?? 0,
+            };
+        }
+        const generationResult = mapGenerateContentResultToChatResult(res.response, {
+            usageMetadata,
         });
-        const generationResult = mapGenerateContentResultToChatResult(res.response);
         await runManager?.handleLLMNewToken(generationResult.generations[0].text ?? "");
         return generationResult;
     }
     async *_streamResponseChunks(messages, options, runManager) {
         const prompt = convertBaseMessagesToContent(messages, this._isMultimodalModel);
         const parameters = this.invocationParams(options);
+        const request = {
+            ...parameters,
+            contents: prompt,
+        };
         const stream = await this.caller.callWithOptions({ signal: options?.signal }, async () => {
-            const { stream } = await this.client.generateContentStream({
-                ...parameters,
-                contents: prompt,
-            });
+            const { stream } = await this.client.generateContentStream(request);
             return stream;
         });
+        let usageMetadata;
+        let index = 0;
         for await (const response of stream) {
-            const chunk = convertResponseContentToChatGenerationChunk(response);
+            if ("usageMetadata" in response &&
+                this.streamUsage !== false &&
+                options.streamUsage !== false) {
+                const genAIUsageMetadata = response.usageMetadata;
+                if (!usageMetadata) {
+                    usageMetadata = {
+                        input_tokens: genAIUsageMetadata.promptTokenCount,
+                        output_tokens: genAIUsageMetadata.candidatesTokenCount,
+                        total_tokens: genAIUsageMetadata.totalTokenCount,
+                    };
+                }
+                else {
+                    // Under the hood, LangChain combines the prompt tokens. Google returns the updated
+                    // total each time, so we need to find the difference between the tokens.
+                    const outputTokenDiff = genAIUsageMetadata.candidatesTokenCount -
+                        usageMetadata.output_tokens;
+                    usageMetadata = {
+                        input_tokens: 0,
+                        output_tokens: outputTokenDiff,
+                        total_tokens: outputTokenDiff,
+                    };
+                }
+            }
+            const chunk = convertResponseContentToChatGenerationChunk(response, {
+                usageMetadata,
+                index,
+            });
+            index += 1;
             if (!chunk) {
                 continue;
             }
@@ -274,6 +308,21 @@ export class ChatGoogleGenerativeAI extends BaseChatModel {
             await runManager?.handleLLMNewToken(chunk.text ?? "");
         }
     }
+    async completionWithRetry(request, options) {
+        return this.caller.callWithOptions({ signal: options?.signal }, async () => {
+            try {
+                return this.client.generateContent(request);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                // TODO: Improve error handling
+                if (e.message?.includes("400 Bad Request")) {
+                    e.status = 400;
+                }
+                throw e;
+            }
+        });
+    }
     withStructuredOutput(outputSchema, config) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         const schema = outputSchema;

package/dist/utils/common.cjs

@@ -10,6 +10,9 @@ function getMessageAuthor(message) {
     if (messages_1.ChatMessage.isInstance(message)) {
         return message.role;
     }
+    if (type === "tool") {
+        return type;
+    }
     return message.name ?? type;
 }
 exports.getMessageAuthor = getMessageAuthor;
@@ -31,6 +34,9 @@ function convertAuthorToRole(author) {
         case "system":
         case "human":
             return "user";
+        case "tool":
+        case "function":
+            return "function";
         default:
             throw new Error(`Unknown / unsupported author: ${author}`);
     }
@@ -47,11 +53,36 @@ function messageContentMedia(content) {
     }
     throw new Error("Invalid media content");
 }
-function convertMessageContentToParts(content, isMultimodalModel) {
-    if (typeof content === "string") {
-        return [{ text: content }];
+function convertMessageContentToParts(message, isMultimodalModel, role) {
+    if (typeof message.content === "string") {
+        return [{ text: message.content }];
+    }
+    let functionCallParts = [];
+    if (role === "function") {
+        if (message.name && typeof message.content === "string") {
+            functionCallParts.push({
+                functionResponse: {
+                    name: message.name,
+                    response: message.content,
+                },
+            });
+        }
+        else {
+            throw new Error("ChatGoogleGenerativeAI requires tool messages to contain the tool name, and a string content.");
+        }
+    }
+    if ("tool_calls" in message) {
+        const castMessage = message;
+        if (castMessage.tool_calls && castMessage.tool_calls.length > 0) {
+            functionCallParts = castMessage.tool_calls.map((tc) => ({
+                functionCall: {
+                    name: tc.name,
+                    args: tc.args,
+                },
+            }));
+        }
     }
-    return content.map((c) => {
+    const messageContentParts = message.content.map((c) => {
         if (c.type === "text") {
             return {
                 text: c.text,
@@ -89,8 +120,17 @@ function convertMessageContentToParts(content, isMultimodalModel) {
         else if (c.type === "media") {
             return messageContentMedia(c);
         }
+        else if (c.type === "tool_use") {
+            return {
+                functionCall: {
+                    name: c.name,
+                    args: c.input,
+                },
+            };
+        }
         throw new Error(`Unknown content type ${c.type}`);
     });
+    return [...messageContentParts, ...functionCallParts];
 }
 exports.convertMessageContentToParts = convertMessageContentToParts;
 function convertBaseMessagesToContent(messages, isMultimodalModel) {
@@ -109,7 +149,7 @@ function convertBaseMessagesToContent(messages, isMultimodalModel) {
             prevContent.role === role) {
             throw new Error("Google Generative AI requires alternate messages between authors");
         }
-        const parts = convertMessageContentToParts(message.content, isMultimodalModel);
+        const parts = convertMessageContentToParts(message, isMultimodalModel, role);
         if (acc.mergeWithPreviousContent) {
             const prevContent = acc.content[acc.content.length - 1];
             if (!prevContent) {
@@ -121,8 +161,13 @@ function convertBaseMessagesToContent(messages, isMultimodalModel) {
                 content: acc.content,
             };
         }
+        let actualRole = role;
+        if (actualRole === "function") {
+            // GenerativeAI API will throw an error if the role is not "user" or "model."
+            actualRole = "user";
+        }
         const content = {
-            role,
+            role: actualRole,
             parts,
         };
         return {
@@ -132,7 +177,7 @@ function convertBaseMessagesToContent(messages, isMultimodalModel) {
     }, { content: [], mergeWithPreviousContent: false }).content;
 }
 exports.convertBaseMessagesToContent = convertBaseMessagesToContent;
-function mapGenerateContentResultToChatResult(response) {
+function mapGenerateContentResultToChatResult(response, extra) {
     // if rejected or error, return empty generations with reason in filters
     if (!response.candidates ||
         response.candidates.length === 0 ||
@@ -156,6 +201,7 @@ function mapGenerateContentResultToChatResult(response) {
             additional_kwargs: {
                 ...generationInfo,
             },
+            usage_metadata: extra?.usageMetadata,
         }),
         generationInfo,
     };
@@ -164,21 +210,32 @@ function mapGenerateContentResultToChatResult(response) {
     };
 }
 exports.mapGenerateContentResultToChatResult = mapGenerateContentResultToChatResult;
-function convertResponseContentToChatGenerationChunk(response) {
+function convertResponseContentToChatGenerationChunk(response, extra) {
     if (!response.candidates || response.candidates.length === 0) {
         return null;
     }
+    const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
     const { content, ...generationInfo } = candidate;
     const text = content?.parts[0]?.text ?? "";
+    const toolCallChunks = [];
+    if (functionCalls) {
+        toolCallChunks.push(...functionCalls.map((fc) => ({
+            ...fc,
+            args: JSON.stringify(fc.args),
+            index: extra.index,
+        })));
+    }
     return new outputs_1.ChatGenerationChunk({
         text,
         message: new messages_1.AIMessageChunk({
             content: text,
             name: !content ? undefined : content.role,
+            tool_call_chunks: toolCallChunks,
             // Each chunk can have unique "generationInfo", and merging strategy is unclear,
             // so leave blank for now.
             additional_kwargs: {},
+            usage_metadata: extra.usageMetadata,
         }),
         generationInfo,
     });

package/dist/utils/common.d.ts

@@ -1,5 +1,5 @@
-import { EnhancedGenerateContentResponse, Content, Part, type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool } from "@google/generative-ai";
-import { BaseMessage, MessageContent } from "@langchain/core/messages";
+import { EnhancedGenerateContentResponse, Content, Part, type FunctionDeclarationsTool as GoogleGenerativeAIFunctionDeclarationsTool, POSSIBLE_ROLES } from "@google/generative-ai";
+import { BaseMessage, UsageMetadata } from "@langchain/core/messages";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
 import { StructuredToolInterface } from "@langchain/core/tools";
 export declare function getMessageAuthor(message: BaseMessage): string;
@@ -9,9 +9,14 @@ export declare function getMessageAuthor(message: BaseMessage): string;
  * @param model The model to use for mapping.
  * @returns The message type mapped to a Google Generative AI chat author.
  */
-export declare function convertAuthorToRole(author: string): "model" | "user";
-export declare function convertMessageContentToParts(content: MessageContent, isMultimodalModel: boolean): Part[];
+export declare function convertAuthorToRole(author: string): (typeof POSSIBLE_ROLES)[number];
+export declare function convertMessageContentToParts(message: BaseMessage, isMultimodalModel: boolean, role: (typeof POSSIBLE_ROLES)[number]): Part[];
 export declare function convertBaseMessagesToContent(messages: BaseMessage[], isMultimodalModel: boolean): Content[];
-export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse): ChatResult;
-export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse): ChatGenerationChunk | null;
+export declare function mapGenerateContentResultToChatResult(response: EnhancedGenerateContentResponse, extra?: {
+    usageMetadata: UsageMetadata | undefined;
+}): ChatResult;
+export declare function convertResponseContentToChatGenerationChunk(response: EnhancedGenerateContentResponse, extra: {
+    usageMetadata?: UsageMetadata | undefined;
+    index: number;
+}): ChatGenerationChunk | null;
 export declare function convertToGenerativeAITools(structuredTools: (StructuredToolInterface | Record<string, unknown>)[]): GoogleGenerativeAIFunctionDeclarationsTool[];

package/dist/utils/common.js

@@ -7,6 +7,9 @@ export function getMessageAuthor(message) {
     if (ChatMessage.isInstance(message)) {
         return message.role;
     }
+    if (type === "tool") {
+        return type;
+    }
     return message.name ?? type;
 }
 /**
@@ -27,6 +30,9 @@ export function convertAuthorToRole(author) {
         case "system":
         case "human":
             return "user";
+        case "tool":
+        case "function":
+            return "function";
         default:
             throw new Error(`Unknown / unsupported author: ${author}`);
     }
@@ -42,11 +48,36 @@ function messageContentMedia(content) {
     }
     throw new Error("Invalid media content");
 }
-export function convertMessageContentToParts(content, isMultimodalModel) {
-    if (typeof content === "string") {
-        return [{ text: content }];
+export function convertMessageContentToParts(message, isMultimodalModel, role) {
+    if (typeof message.content === "string") {
+        return [{ text: message.content }];
+    }
+    let functionCallParts = [];
+    if (role === "function") {
+        if (message.name && typeof message.content === "string") {
+            functionCallParts.push({
+                functionResponse: {
+                    name: message.name,
+                    response: message.content,
+                },
+            });
+        }
+        else {
+            throw new Error("ChatGoogleGenerativeAI requires tool messages to contain the tool name, and a string content.");
+        }
+    }
+    if ("tool_calls" in message) {
+        const castMessage = message;
+        if (castMessage.tool_calls && castMessage.tool_calls.length > 0) {
+            functionCallParts = castMessage.tool_calls.map((tc) => ({
+                functionCall: {
+                    name: tc.name,
+                    args: tc.args,
+                },
+            }));
+        }
     }
-    return content.map((c) => {
+    const messageContentParts = message.content.map((c) => {
         if (c.type === "text") {
             return {
                 text: c.text,
@@ -84,8 +115,17 @@ export function convertMessageContentToParts(content, isMultimodalModel) {
         else if (c.type === "media") {
             return messageContentMedia(c);
         }
+        else if (c.type === "tool_use") {
+            return {
+                functionCall: {
+                    name: c.name,
+                    args: c.input,
+                },
+            };
+        }
         throw new Error(`Unknown content type ${c.type}`);
     });
+    return [...messageContentParts, ...functionCallParts];
 }
 export function convertBaseMessagesToContent(messages, isMultimodalModel) {
     return messages.reduce((acc, message, index) => {
@@ -103,7 +143,7 @@ export function convertBaseMessagesToContent(messages, isMultimodalModel) {
             prevContent.role === role) {
             throw new Error("Google Generative AI requires alternate messages between authors");
         }
-        const parts = convertMessageContentToParts(message.content, isMultimodalModel);
+        const parts = convertMessageContentToParts(message, isMultimodalModel, role);
         if (acc.mergeWithPreviousContent) {
             const prevContent = acc.content[acc.content.length - 1];
             if (!prevContent) {
@@ -115,8 +155,13 @@ export function convertBaseMessagesToContent(messages, isMultimodalModel) {
                 content: acc.content,
             };
         }
+        let actualRole = role;
+        if (actualRole === "function") {
+            // GenerativeAI API will throw an error if the role is not "user" or "model."
+            actualRole = "user";
+        }
         const content = {
-            role,
+            role: actualRole,
             parts,
         };
         return {
@@ -125,7 +170,7 @@ export function convertBaseMessagesToContent(messages, isMultimodalModel) {
         };
     }, { content: [], mergeWithPreviousContent: false }).content;
 }
-export function mapGenerateContentResultToChatResult(response) {
+export function mapGenerateContentResultToChatResult(response, extra) {
     // if rejected or error, return empty generations with reason in filters
     if (!response.candidates ||
         response.candidates.length === 0 ||
@@ -149,6 +194,7 @@ export function mapGenerateContentResultToChatResult(response) {
             additional_kwargs: {
                 ...generationInfo,
             },
+            usage_metadata: extra?.usageMetadata,
         }),
         generationInfo,
     };
@@ -156,21 +202,32 @@ export function mapGenerateContentResultToChatResult(response) {
         generations: [generation],
     };
 }
-export function convertResponseContentToChatGenerationChunk(response) {
+export function convertResponseContentToChatGenerationChunk(response, extra) {
     if (!response.candidates || response.candidates.length === 0) {
         return null;
     }
+    const functionCalls = response.functionCalls();
     const [candidate] = response.candidates;
     const { content, ...generationInfo } = candidate;
     const text = content?.parts[0]?.text ?? "";
+    const toolCallChunks = [];
+    if (functionCalls) {
+        toolCallChunks.push(...functionCalls.map((fc) => ({
+            ...fc,
+            args: JSON.stringify(fc.args),
+            index: extra.index,
+        })));
+    }
     return new ChatGenerationChunk({
         text,
         message: new AIMessageChunk({
             content: text,
             name: !content ? undefined : content.role,
+            tool_call_chunks: toolCallChunks,
             // Each chunk can have unique "generationInfo", and merging strategy is unclear,
             // so leave blank for now.
             additional_kwargs: {},
+            usage_metadata: extra.usageMetadata,
         }),
         generationInfo,
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-genai",
-  "version": "0.0.17",
+  "version": "0.0.18",
   "description": "Sample integration for LangChain.js",
   "type": "module",
   "engines": {
@@ -36,13 +36,13 @@
   "license": "MIT",
   "dependencies": {
     "@google/generative-ai": "^0.7.0",
-    "@langchain/core": ">0.1.5  <0.3.0",
+    "@langchain/core": ">=0.2.5 <0.3.0",
     "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
     "@langchain/scripts": "~0.0.14",
-    "@langchain/standard-tests": "workspace:*",
+    "@langchain/standard-tests": "0.0.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",