@langchain/google-common 0.0.27 → 0.1.0

package/dist/utils/gemini.js

@@ -11,73 +11,80 @@ const extractMimeType = (str) => {
     }
     return null;
 };
-function messageContentText(content) {
-    if (content?.text && content?.text.length > 0) {
-        return {
-            text: content.text,
-        };
-    }
-    else {
-        return null;
+export function getGeminiAPI(config) {
+    function messageContentText(content) {
+        if (content?.text && content?.text.length > 0) {
+            return {
+                text: content.text,
+            };
+        }
+        else {
+            return null;
+        }
     }
-}
-function messageContentImageUrl(content) {
-    const url = typeof content.image_url === "string"
-        ? content.image_url
-        : content.image_url.url;
-    if (!url) {
-        throw new Error("Missing Image URL");
-    }
-    const mineTypeAndData = extractMimeType(url);
-    if (mineTypeAndData) {
-        return {
-            inlineData: mineTypeAndData,
-        };
+    function messageContentImageUrl(content) {
+        const url = typeof content.image_url === "string"
+            ? content.image_url
+            : content.image_url.url;
+        if (!url) {
+            throw new Error("Missing Image URL");
+        }
+        const mineTypeAndData = extractMimeType(url);
+        if (mineTypeAndData) {
+            return {
+                inlineData: mineTypeAndData,
+            };
+        }
+        else {
+            // FIXME - need some way to get mime type
+            return {
+                fileData: {
+                    mimeType: "image/png",
+                    fileUri: url,
+                },
+            };
+        }
     }
-    else {
-        // FIXME - need some way to get mime type
+    async function blobToFileData(blob) {
         return {
             fileData: {
-                mimeType: "image/png",
-                fileUri: url,
-            },
-        };
-    }
-}
-function messageContentMedia(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-content) {
-    if ("mimeType" in content && "data" in content) {
-        return {
-            inlineData: {
-                mimeType: content.mimeType,
-                data: content.data,
+                fileUri: blob.path,
+                mimeType: blob.mimetype,
             },
         };
     }
-    else if ("mimeType" in content && "fileUri" in content) {
-        return {
-            fileData: {
-                mimeType: content.mimeType,
-                fileUri: content.fileUri,
-            },
-        };
+    async function fileUriContentToBlob(uri) {
+        return config?.mediaManager?.getMediaBlob(uri);
+    }
+    async function messageContentMedia(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    content) {
+        if ("mimeType" in content && "data" in content) {
+            return {
+                inlineData: {
+                    mimeType: content.mimeType,
+                    data: content.data,
+                },
+            };
+        }
+        else if ("mimeType" in content && "fileUri" in content) {
+            return {
+                fileData: {
+                    mimeType: content.mimeType,
+                    fileUri: content.fileUri,
+                },
+            };
+        }
+        else {
+            const uri = content.fileUri;
+            const blob = await fileUriContentToBlob(uri);
+            if (blob) {
+                return await blobToFileData(blob);
+            }
+        }
+        throw new Error("Invalid media content");
     }
-    throw new Error("Invalid media content");
-}
-export function messageContentToParts(content) {
-    // Convert a string to a text type MessageContent if needed
-    const messageContent = typeof content === "string"
-        ? [
-            {
-                type: "text",
-                text: content,
-            },
-        ]
-        : content;
-    // eslint-disable-next-line array-callback-return
-    const parts = messageContent
-        .map((content) => {
+    async function messageContentComplexToPart(content) {
         switch (content.type) {
             case "text":
                 if ("text" in content) {
@@ -91,464 +98,481 @@ export function messageContentToParts(content) {
                 }
                 break;
             case "media":
-                return messageContentMedia(content);
+                return await messageContentMedia(content);
             default:
                 throw new Error(`Unsupported type received while converting message to message parts`);
         }
         throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
-    })
-        .reduce((acc, val) => {
-        if (val) {
-            return [...acc, val];
+    }
+    async function messageContentComplexToParts(content) {
+        const contents = content.map(messageContentComplexToPart);
+        return Promise.all(contents);
+    }
+    async function messageContentToParts(content) {
+        // Convert a string to a text type MessageContent if needed
+        const messageContent = typeof content === "string"
+            ? [
+                {
+                    type: "text",
+                    text: content,
+                },
+            ]
+            : content;
+        // Get all of the parts, even those that don't correctly resolve
+        const allParts = await messageContentComplexToParts(messageContent);
+        // Remove any invalid parts
+        const parts = allParts.reduce((acc, val) => {
+            if (val) {
+                return [...acc, val];
+            }
+            else {
+                return acc;
+            }
+        }, []);
+        return parts;
+    }
+    function messageToolCallsToParts(toolCalls) {
+        if (!toolCalls || toolCalls.length === 0) {
+            return [];
+        }
+        return toolCalls.map((tool) => {
+            let args = {};
+            if (tool?.function?.arguments) {
+                const argStr = tool.function.arguments;
+                args = JSON.parse(argStr);
+            }
+            return {
+                functionCall: {
+                    name: tool.function.name,
+                    args,
+                },
+            };
+        });
+    }
+    function messageKwargsToParts(kwargs) {
+        const ret = [];
+        if (kwargs?.tool_calls) {
+            ret.push(...messageToolCallsToParts(kwargs.tool_calls));
+        }
+        return ret;
+    }
+    async function roleMessageToContent(role, message) {
+        const contentParts = await messageContentToParts(message.content);
+        let toolParts;
+        if (isAIMessage(message) && !!message.tool_calls?.length) {
+            toolParts = message.tool_calls.map((toolCall) => ({
+                functionCall: {
+                    name: toolCall.name,
+                    args: toolCall.args,
+                },
+            }));
         }
         else {
-            return acc;
+            toolParts = messageKwargsToParts(message.additional_kwargs);
+        }
+        const parts = [...contentParts, ...toolParts];
+        return [
+            {
+                role,
+                parts,
+            },
+        ];
+    }
+    async function systemMessageToContent(message, useSystemInstruction) {
+        return useSystemInstruction
+            ? roleMessageToContent("system", message)
+            : [
+                ...(await roleMessageToContent("user", message)),
+                ...(await roleMessageToContent("model", new AIMessage("Ok"))),
+            ];
+    }
+    function toolMessageToContent(message, prevMessage) {
+        const contentStr = typeof message.content === "string"
+            ? message.content
+            : message.content.reduce((acc, content) => {
+                if (content.type === "text") {
+                    return acc + content.text;
+                }
+                else {
+                    return acc;
+                }
+            }, "");
+        // Hacky :(
+        const responseName = (isAIMessage(prevMessage) && !!prevMessage.tool_calls?.length
+            ? prevMessage.tool_calls[0].name
+            : prevMessage.name) ?? message.tool_call_id;
+        try {
+            const content = JSON.parse(contentStr);
+            return [
+                {
+                    role: "function",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: responseName,
+                                response: { content },
+                            },
+                        },
+                    ],
+                },
+            ];
+        }
+        catch (_) {
+            return [
+                {
+                    role: "function",
+                    parts: [
+                        {
+                            functionResponse: {
+                                name: responseName,
+                                response: { content: contentStr },
+                            },
+                        },
+                    ],
+                },
+            ];
         }
-    }, []);
-    return parts;
-}
-function messageToolCallsToParts(toolCalls) {
-    if (!toolCalls || toolCalls.length === 0) {
-        return [];
     }
-    return toolCalls.map((tool) => {
-        let args = {};
-        if (tool?.function?.arguments) {
-            const argStr = tool.function.arguments;
-            args = JSON.parse(argStr);
+    async function baseMessageToContent(message, prevMessage, useSystemInstruction) {
+        const type = message._getType();
+        switch (type) {
+            case "system":
+                return systemMessageToContent(message, useSystemInstruction);
+            case "human":
+                return roleMessageToContent("user", message);
+            case "ai":
+                return roleMessageToContent("model", message);
+            case "tool":
+                if (!prevMessage) {
+                    throw new Error("Tool messages cannot be the first message passed to the model.");
+                }
+                return toolMessageToContent(message, prevMessage);
+            default:
+                console.log(`Unsupported message type: ${type}`);
+                return [];
         }
+    }
+    function textPartToMessageContent(part) {
         return {
-            functionCall: {
-                name: tool.function.name,
-                args,
-            },
+            type: "text",
+            text: part.text,
         };
-    });
-}
-function messageKwargsToParts(kwargs) {
-    const ret = [];
-    if (kwargs?.tool_calls) {
-        ret.push(...messageToolCallsToParts(kwargs.tool_calls));
     }
-    return ret;
-}
-function roleMessageToContent(role, message) {
-    const contentParts = messageContentToParts(message.content);
-    let toolParts;
-    if (isAIMessage(message) && !!message.tool_calls?.length) {
-        toolParts = message.tool_calls.map((toolCall) => ({
-            functionCall: {
-                name: toolCall.name,
-                args: toolCall.args,
-            },
-        }));
-    }
-    else {
-        toolParts = messageKwargsToParts(message.additional_kwargs);
-    }
-    const parts = [...contentParts, ...toolParts];
-    return [
-        {
-            role,
-            parts,
-        },
-    ];
-}
-function systemMessageToContent(message, useSystemInstruction) {
-    return useSystemInstruction
-        ? roleMessageToContent("system", message)
-        : [
-            ...roleMessageToContent("user", message),
-            ...roleMessageToContent("model", new AIMessage("Ok")),
-        ];
-}
-function toolMessageToContent(message, prevMessage) {
-    const contentStr = typeof message.content === "string"
-        ? message.content
-        : message.content.reduce((acc, content) => {
-            if (content.type === "text") {
-                return acc + content.text;
+    function inlineDataPartToMessageContent(part) {
+        return {
+            type: "image_url",
+            image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
+        };
+    }
+    function fileDataPartToMessageContent(part) {
+        return {
+            type: "image_url",
+            image_url: part.fileData.fileUri,
+        };
+    }
+    function partsToMessageContent(parts) {
+        return parts
+            .map((part) => {
+            if (part === undefined || part === null) {
+                return null;
+            }
+            else if ("text" in part) {
+                return textPartToMessageContent(part);
+            }
+            else if ("inlineData" in part) {
+                return inlineDataPartToMessageContent(part);
+            }
+            else if ("fileData" in part) {
+                return fileDataPartToMessageContent(part);
             }
             else {
-                return acc;
+                return null;
             }
-        }, "");
-    // Hacky :(
-    const responseName = (isAIMessage(prevMessage) && !!prevMessage.tool_calls?.length
-        ? prevMessage.tool_calls[0].name
-        : prevMessage.name) ?? message.tool_call_id;
-    try {
-        const content = JSON.parse(contentStr);
-        return [
-            {
-                role: "function",
-                parts: [
-                    {
-                        functionResponse: {
-                            name: responseName,
-                            response: { content },
-                        },
-                    },
-                ],
+        })
+            .reduce((acc, content) => {
+            if (content) {
+                acc.push(content);
+            }
+            return acc;
+        }, []);
+    }
+    function toolRawToTool(raw) {
+        return {
+            id: raw.id,
+            type: raw.type,
+            function: {
+                name: raw.function.name,
+                arguments: JSON.stringify(raw.function.arguments),
             },
-        ];
+        };
     }
-    catch (_) {
-        return [
-            {
-                role: "function",
-                parts: [
-                    {
-                        functionResponse: {
-                            name: responseName,
-                            response: { content: contentStr },
-                        },
-                    },
-                ],
+    function functionCallPartToToolRaw(part) {
+        return {
+            id: uuidv4().replace(/-/g, ""),
+            type: "function",
+            function: {
+                name: part.functionCall.name,
+                arguments: part.functionCall.args ?? {},
             },
-        ];
+        };
     }
-}
-export function baseMessageToContent(message, prevMessage, useSystemInstruction) {
-    const type = message._getType();
-    switch (type) {
-        case "system":
-            return systemMessageToContent(message, useSystemInstruction);
-        case "human":
-            return roleMessageToContent("user", message);
-        case "ai":
-            return roleMessageToContent("model", message);
-        case "tool":
-            if (!prevMessage) {
-                throw new Error("Tool messages cannot be the first message passed to the model.");
+    function partsToToolsRaw(parts) {
+        return parts
+            .map((part) => {
+            if (part === undefined || part === null) {
+                return null;
             }
-            return toolMessageToContent(message, prevMessage);
-        default:
-            console.log(`Unsupported message type: ${type}`);
-            return [];
+            else if ("functionCall" in part) {
+                return functionCallPartToToolRaw(part);
+            }
+            else {
+                return null;
+            }
+        })
+            .reduce((acc, content) => {
+            if (content) {
+                acc.push(content);
+            }
+            return acc;
+        }, []);
     }
-}
-function textPartToMessageContent(part) {
-    return {
-        type: "text",
-        text: part.text,
-    };
-}
-function inlineDataPartToMessageContent(part) {
-    return {
-        type: "image_url",
-        image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
-    };
-}
-function fileDataPartToMessageContent(part) {
-    return {
-        type: "image_url",
-        image_url: part.fileData.fileUri,
-    };
-}
-export function partsToMessageContent(parts) {
-    return parts
-        .map((part) => {
-        if (part === undefined || part === null) {
-            return null;
-        }
-        else if ("text" in part) {
-            return textPartToMessageContent(part);
-        }
-        else if ("inlineData" in part) {
-            return inlineDataPartToMessageContent(part);
-        }
-        else if ("fileData" in part) {
-            return fileDataPartToMessageContent(part);
-        }
-        else {
-            return null;
-        }
-    })
-        .reduce((acc, content) => {
-        if (content) {
-            acc.push(content);
-        }
-        return acc;
-    }, []);
-}
-function toolRawToTool(raw) {
-    return {
-        id: raw.id,
-        type: raw.type,
-        function: {
-            name: raw.function.name,
-            arguments: JSON.stringify(raw.function.arguments),
-        },
-    };
-}
-function functionCallPartToToolRaw(part) {
-    return {
-        id: uuidv4().replace(/-/g, ""),
-        type: "function",
-        function: {
-            name: part.functionCall.name,
-            arguments: part.functionCall.args ?? {},
-        },
-    };
-}
-export function partsToToolsRaw(parts) {
-    return parts
-        .map((part) => {
-        if (part === undefined || part === null) {
-            return null;
+    function toolsRawToTools(raws) {
+        return raws.map((raw) => toolRawToTool(raw));
+    }
+    function responseToGenerateContentResponseData(response) {
+        if ("nextChunk" in response.data) {
+            throw new Error("Cannot convert Stream to GenerateContentResponseData");
         }
-        else if ("functionCall" in part) {
-            return functionCallPartToToolRaw(part);
+        else if (Array.isArray(response.data)) {
+            // Collapse the array of response data as if it was a single one
+            return response.data.reduce((acc, val) => {
+                // Add all the parts
+                // FIXME: Handle other candidates?
+                const valParts = val?.candidates?.[0]?.content?.parts ?? [];
+                acc.candidates[0].content.parts.push(...valParts);
+                // FIXME: Merge promptFeedback and safety settings
+                acc.promptFeedback = val.promptFeedback;
+                return acc;
+            });
         }
         else {
-            return null;
-        }
-    })
-        .reduce((acc, content) => {
-        if (content) {
-            acc.push(content);
+            return response.data;
         }
-        return acc;
-    }, []);
-}
-export function toolsRawToTools(raws) {
-    return raws.map((raw) => toolRawToTool(raw));
-}
-export function responseToGenerateContentResponseData(response) {
-    if ("nextChunk" in response.data) {
-        throw new Error("Cannot convert Stream to GenerateContentResponseData");
-    }
-    else if (Array.isArray(response.data)) {
-        // Collapse the array of response data as if it was a single one
-        return response.data.reduce((acc, val) => {
-            // Add all the parts
-            // FIXME: Handle other candidates?
-            const valParts = val?.candidates?.[0]?.content?.parts ?? [];
-            acc.candidates[0].content.parts.push(...valParts);
-            // FIXME: Merge promptFeedback and safety settings
-            acc.promptFeedback = val.promptFeedback;
-            return acc;
-        });
     }
-    else {
-        return response.data;
+    function responseToParts(response) {
+        const responseData = responseToGenerateContentResponseData(response);
+        const parts = responseData?.candidates?.[0]?.content?.parts ?? [];
+        return parts;
     }
-}
-export function responseToParts(response) {
-    const responseData = responseToGenerateContentResponseData(response);
-    const parts = responseData?.candidates?.[0]?.content?.parts ?? [];
-    return parts;
-}
-export function partToText(part) {
-    return "text" in part ? part.text : "";
-}
-export function responseToString(response) {
-    const parts = responseToParts(response);
-    const ret = parts.reduce((acc, part) => {
-        const val = partToText(part);
-        return acc + val;
-    }, "");
-    return ret;
-}
-function safeResponseTo(response, safetyHandler, responseTo) {
-    try {
-        const safeResponse = safetyHandler.handle(response);
-        return responseTo(safeResponse);
+    function partToText(part) {
+        return "text" in part ? part.text : "";
     }
-    catch (xx) {
-        // eslint-disable-next-line no-instanceof/no-instanceof
-        if (xx instanceof GoogleAISafetyError) {
-            const ret = responseTo(xx.response);
-            xx.reply = ret;
+    function responseToString(response) {
+        const parts = responseToParts(response);
+        const ret = parts.reduce((acc, part) => {
+            const val = partToText(part);
+            return acc + val;
+        }, "");
+        return ret;
+    }
+    function safeResponseTo(response, safetyHandler, responseTo) {
+        try {
+            const safeResponse = safetyHandler.handle(response);
+            return responseTo(safeResponse);
+        }
+        catch (xx) {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (xx instanceof GoogleAISafetyError) {
+                const ret = responseTo(xx.response);
+                xx.reply = ret;
+            }
+            throw xx;
         }
-        throw xx;
     }
-}
-export function safeResponseToString(response, safetyHandler) {
-    return safeResponseTo(response, safetyHandler, responseToString);
-}
-export function responseToGenerationInfo(response) {
-    if (!Array.isArray(response.data)) {
-        return {};
+    function safeResponseToString(response, safetyHandler) {
+        return safeResponseTo(response, safetyHandler, responseToString);
     }
-    const data = response.data[0];
-    return {
-        usage_metadata: {
-            prompt_token_count: data.usageMetadata?.promptTokenCount,
-            candidates_token_count: data.usageMetadata?.candidatesTokenCount,
-            total_token_count: data.usageMetadata?.totalTokenCount,
-        },
-        safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({
-            category: rating.category,
-            probability: rating.probability,
-            probability_score: rating.probabilityScore,
-            severity: rating.severity,
-            severity_score: rating.severityScore,
-        })),
-        finish_reason: data.candidates[0]?.finishReason,
-    };
-}
-export function responseToGeneration(response) {
-    return {
-        text: responseToString(response),
-        generationInfo: responseToGenerationInfo(response),
-    };
-}
-export function safeResponseToGeneration(response, safetyHandler) {
-    return safeResponseTo(response, safetyHandler, responseToGeneration);
-}
-export function responseToChatGeneration(response) {
-    return new ChatGenerationChunk({
-        text: responseToString(response),
-        message: partToMessageChunk(responseToParts(response)[0]),
-        generationInfo: responseToGenerationInfo(response),
-    });
-}
-export function safeResponseToChatGeneration(response, safetyHandler) {
-    return safeResponseTo(response, safetyHandler, responseToChatGeneration);
-}
-export function chunkToString(chunk) {
-    if (chunk === null) {
-        return "";
-    }
-    else if (typeof chunk.content === "string") {
-        return chunk.content;
+    function responseToGenerationInfo(response) {
+        if (!Array.isArray(response.data)) {
+            return {};
+        }
+        const data = response.data[0];
+        return {
+            usage_metadata: {
+                prompt_token_count: data.usageMetadata?.promptTokenCount,
+                candidates_token_count: data.usageMetadata?.candidatesTokenCount,
+                total_token_count: data.usageMetadata?.totalTokenCount,
+            },
+            safety_ratings: data.candidates[0]?.safetyRatings?.map((rating) => ({
+                category: rating.category,
+                probability: rating.probability,
+                probability_score: rating.probabilityScore,
+                severity: rating.severity,
+                severity_score: rating.severityScore,
+            })),
+            finish_reason: data.candidates[0]?.finishReason,
+        };
     }
-    else if (chunk.content.length === 0) {
-        return "";
+    function responseToChatGeneration(response) {
+        return new ChatGenerationChunk({
+            text: responseToString(response),
+            message: partToMessageChunk(responseToParts(response)[0]),
+            generationInfo: responseToGenerationInfo(response),
+        });
     }
-    else if (chunk.content[0].type === "text") {
-        return chunk.content[0].text;
+    function safeResponseToChatGeneration(response, safetyHandler) {
+        return safeResponseTo(response, safetyHandler, responseToChatGeneration);
     }
-    else {
-        throw new Error(`Unexpected chunk: ${chunk}`);
+    function chunkToString(chunk) {
+        if (chunk === null) {
+            return "";
+        }
+        else if (typeof chunk.content === "string") {
+            return chunk.content;
+        }
+        else if (chunk.content.length === 0) {
+            return "";
+        }
+        else if (chunk.content[0].type === "text") {
+            return chunk.content[0].text;
+        }
+        else {
+            throw new Error(`Unexpected chunk: ${chunk}`);
+        }
     }
-}
-export function partToMessageChunk(part) {
-    const fields = partsToBaseMessageChunkFields([part]);
-    if (typeof fields.content === "string") {
+    function partToMessageChunk(part) {
+        const fields = partsToBaseMessageChunkFields([part]);
+        if (typeof fields.content === "string") {
+            return new AIMessageChunk(fields);
+        }
+        else if (fields.content.every((item) => item.type === "text")) {
+            const newContent = fields.content
+                .map((item) => ("text" in item ? item.text : ""))
+                .join("");
+            return new AIMessageChunk({
+                ...fields,
+                content: newContent,
+            });
+        }
         return new AIMessageChunk(fields);
     }
-    else if (fields.content.every((item) => item.type === "text")) {
-        const newContent = fields.content
-            .map((item) => ("text" in item ? item.text : ""))
-            .join("");
-        return new AIMessageChunk({
-            ...fields,
-            content: newContent,
+    function partToChatGeneration(part) {
+        const message = partToMessageChunk(part);
+        const text = partToText(part);
+        return new ChatGenerationChunk({
+            text,
+            message,
         });
     }
-    return new AIMessageChunk(fields);
-}
-export function partToChatGeneration(part) {
-    const message = partToMessageChunk(part);
-    const text = partToText(part);
-    return new ChatGenerationChunk({
-        text,
-        message,
-    });
-}
-export function responseToChatGenerations(response) {
-    const parts = responseToParts(response);
-    let ret = parts.map((part) => partToChatGeneration(part));
-    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,
-            }),
-        ];
-    }
-    return ret;
-}
-export function responseToBaseMessageFields(response) {
-    const parts = responseToParts(response);
-    return partsToBaseMessageChunkFields(parts);
-}
-export function partsToBaseMessageChunkFields(parts) {
-    const fields = {
-        content: partsToMessageContent(parts),
-        tool_call_chunks: [],
-        tool_calls: [],
-        invalid_tool_calls: [],
-    };
-    const rawTools = partsToToolsRaw(parts);
-    if (rawTools.length > 0) {
-        const tools = toolsRawToTools(rawTools);
-        for (const tool of tools) {
-            fields.tool_call_chunks?.push({
-                name: tool.function.name,
-                args: tool.function.arguments,
-                id: tool.id,
+    function responseToChatGenerations(response) {
+        const parts = responseToParts(response);
+        let ret = parts.map((part) => partToChatGeneration(part));
+        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",
-            });
-            try {
-                fields.tool_calls?.push({
-                    name: tool.function.name,
-                    args: JSON.parse(tool.function.arguments),
-                    id: tool.id,
-                    type: "tool_call",
-                });
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }));
+            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,
+                };
             }
-            catch (e) {
-                fields.invalid_tool_calls?.push({
+            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,
+                }),
+            ];
+        }
+        return ret;
+    }
+    function responseToBaseMessageFields(response) {
+        const parts = responseToParts(response);
+        return partsToBaseMessageChunkFields(parts);
+    }
+    function partsToBaseMessageChunkFields(parts) {
+        const fields = {
+            content: partsToMessageContent(parts),
+            tool_call_chunks: [],
+            tool_calls: [],
+            invalid_tool_calls: [],
+        };
+        const rawTools = partsToToolsRaw(parts);
+        if (rawTools.length > 0) {
+            const tools = toolsRawToTools(rawTools);
+            for (const tool of tools) {
+                fields.tool_call_chunks?.push({
                     name: tool.function.name,
                     args: tool.function.arguments,
                     id: tool.id,
-                    error: e.message,
-                    type: "invalid_tool_call",
+                    type: "tool_call_chunk",
                 });
+                try {
+                    fields.tool_calls?.push({
+                        name: tool.function.name,
+                        args: JSON.parse(tool.function.arguments),
+                        id: tool.id,
+                    });
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    fields.invalid_tool_calls?.push({
+                        name: tool.function.name,
+                        args: tool.function.arguments,
+                        id: tool.id,
+                        error: e.message,
+                        type: "invalid_tool_call",
+                    });
+                }
             }
+            fields.additional_kwargs = {
+                tool_calls: tools,
+            };
         }
-        fields.additional_kwargs = {
-            tool_calls: tools,
+        return fields;
+    }
+    function responseToBaseMessage(response) {
+        const fields = responseToBaseMessageFields(response);
+        return new AIMessage(fields);
+    }
+    function safeResponseToBaseMessage(response, safetyHandler) {
+        return safeResponseTo(response, safetyHandler, responseToBaseMessage);
+    }
+    function responseToChatResult(response) {
+        const generations = responseToChatGenerations(response);
+        return {
+            generations,
+            llmOutput: responseToGenerationInfo(response),
         };
     }
-    return fields;
-}
-export function responseToBaseMessage(response) {
-    const fields = responseToBaseMessageFields(response);
-    return new AIMessage(fields);
-}
-export function safeResponseToBaseMessage(response, safetyHandler) {
-    return safeResponseTo(response, safetyHandler, responseToBaseMessage);
-}
-export function responseToChatResult(response) {
-    const generations = responseToChatGenerations(response);
+    function safeResponseToChatResult(response, safetyHandler) {
+        return safeResponseTo(response, safetyHandler, responseToChatResult);
+    }
     return {
-        generations,
-        llmOutput: responseToGenerationInfo(response),
+        messageContentToParts,
+        baseMessageToContent,
+        safeResponseToString,
+        safeResponseToChatGeneration,
+        chunkToString,
+        safeResponseToBaseMessage,
+        safeResponseToChatResult,
     };
 }
-export function safeResponseToChatResult(response, safetyHandler) {
-    return safeResponseTo(response, safetyHandler, responseToChatResult);
-}
 export function validateGeminiParams(params) {
     if (params.maxOutputTokens && params.maxOutputTokens < 0) {
         throw new Error("`maxOutputTokens` must be a positive integer");