@langchain/google-common 0.0.0

package/dist/utils/gemini.cjs

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isModelGemini = exports.validateGeminiParams = exports.responseToChatResult = exports.responseToBaseMessage = exports.responseToMessageContent = exports.responseToChatGenerations = exports.partToChatGeneration = exports.partToMessage = exports.responseToChatGeneration = exports.responseToGeneration = exports.responseToString = exports.partToText = exports.responseToParts = exports.responseToGenerateContentResponseData = exports.partsToMessageContent = exports.baseMessageToContent = exports.messageContentToParts = void 0;
+const messages_1 = require("@langchain/core/messages");
+const outputs_1 = require("@langchain/core/outputs");
+function messageContentText(content) {
+    return {
+        text: content.text,
+    };
+}
+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");
+    }
+    if (url.startsWith("data:")) {
+        return {
+            mimeType: url.split(":")[1].split(";")[0],
+            data: url.split(",")[1],
+        };
+    }
+    else {
+        // FIXME - need some way to get mime type
+        return {
+            mimeType: "image/png",
+            fileUri: url,
+        };
+    }
+}
+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) => {
+        // eslint-disable-next-line default-case
+        switch (content.type) {
+            case "text":
+                return messageContentText(content);
+            case "image_url":
+                return messageContentImageUrl(content);
+        }
+    });
+    return parts;
+}
+exports.messageContentToParts = messageContentToParts;
+function roleMessageToContent(role, message) {
+    return [
+        {
+            role,
+            parts: messageContentToParts(message.content),
+        },
+    ];
+}
+function systemMessageToContent(message) {
+    return [
+        ...roleMessageToContent("user", message),
+        ...roleMessageToContent("model", new messages_1.AIMessage("Ok")),
+    ];
+}
+function baseMessageToContent(message) {
+    const type = message._getType();
+    switch (type) {
+        case "system":
+            return systemMessageToContent(message);
+        case "human":
+            return roleMessageToContent("user", message);
+        case "ai":
+            return roleMessageToContent("model", message);
+        default:
+            console.log(`Unsupported message type: ${type}`);
+            return [];
+    }
+}
+exports.baseMessageToContent = baseMessageToContent;
+function textPartToMessageContent(part) {
+    return {
+        type: "text",
+        text: part.text,
+    };
+}
+function inlineDataPartToMessageContent(part) {
+    return {
+        type: "image_url",
+        image_url: `data:${part.mimeType};base64,${part.data}`,
+    };
+}
+function fileDataPartToMessageContent(part) {
+    return {
+        type: "image_url",
+        image_url: part.fileUri,
+    };
+}
+function partsToMessageContent(parts) {
+    return parts
+        .map((part) => {
+        if ("text" in part) {
+            return textPartToMessageContent(part);
+        }
+        else if ("mimeType" in part && "data" in part) {
+            return inlineDataPartToMessageContent(part);
+        }
+        else if ("mimeType" in part && "fileUri" in part) {
+            return fileDataPartToMessageContent(part);
+        }
+        else {
+            return null;
+        }
+    })
+        .reduce((acc, content) => {
+        if (content) {
+            acc.push(content);
+        }
+        return acc;
+    }, []);
+}
+exports.partsToMessageContent = partsToMessageContent;
+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;
+    }
+}
+exports.responseToGenerateContentResponseData = responseToGenerateContentResponseData;
+function responseToParts(response) {
+    const responseData = responseToGenerateContentResponseData(response);
+    const parts = responseData?.candidates?.[0]?.content?.parts ?? [];
+    return parts;
+}
+exports.responseToParts = responseToParts;
+function partToText(part) {
+    return "text" in part ? part.text : "";
+}
+exports.partToText = partToText;
+function responseToString(response) {
+    const parts = responseToParts(response);
+    const ret = parts.reduce((acc, part) => {
+        const val = partToText(part);
+        return acc + val;
+    }, "");
+    return ret;
+}
+exports.responseToString = responseToString;
+function responseToGeneration(response) {
+    return {
+        text: responseToString(response),
+        generationInfo: response,
+    };
+}
+exports.responseToGeneration = responseToGeneration;
+function responseToChatGeneration(response) {
+    return new outputs_1.ChatGenerationChunk({
+        text: responseToString(response),
+        message: partToMessage(responseToParts(response)[0]),
+        generationInfo: response,
+    });
+}
+exports.responseToChatGeneration = responseToChatGeneration;
+function partToMessage(part) {
+    const content = partsToMessageContent([part]);
+    return new messages_1.AIMessageChunk({ content });
+}
+exports.partToMessage = partToMessage;
+function partToChatGeneration(part) {
+    const message = partToMessage(part);
+    const text = partToText(part);
+    return new outputs_1.ChatGenerationChunk({
+        text,
+        message,
+    });
+}
+exports.partToChatGeneration = partToChatGeneration;
+function responseToChatGenerations(response) {
+    const parts = responseToParts(response);
+    const ret = parts.map((part) => partToChatGeneration(part));
+    return ret;
+}
+exports.responseToChatGenerations = responseToChatGenerations;
+function responseToMessageContent(response) {
+    const parts = responseToParts(response);
+    return partsToMessageContent(parts);
+}
+exports.responseToMessageContent = responseToMessageContent;
+function responseToBaseMessage(response) {
+    return new messages_1.AIMessage({
+        content: responseToMessageContent(response),
+    });
+}
+exports.responseToBaseMessage = responseToBaseMessage;
+function responseToChatResult(response) {
+    const generations = responseToChatGenerations(response);
+    return {
+        generations,
+        llmOutput: response,
+    };
+}
+exports.responseToChatResult = responseToChatResult;
+function validateGeminiParams(params) {
+    if (params.maxOutputTokens && params.maxOutputTokens < 0) {
+        throw new Error("`maxOutputTokens` must be a positive integer");
+    }
+    if (params.temperature &&
+        (params.temperature < 0 || params.temperature > 1)) {
+        throw new Error("`temperature` must be in the range of [0.0,1.0]");
+    }
+    if (params.topP && (params.topP < 0 || params.topP > 1)) {
+        throw new Error("`topP` must be in the range of [0.0,1.0]");
+    }
+    if (params.topK && params.topK < 0) {
+        throw new Error("`topK` must be a positive integer");
+    }
+}
+exports.validateGeminiParams = validateGeminiParams;
+function isModelGemini(modelName) {
+    return modelName.toLowerCase().startsWith("gemini");
+}
+exports.isModelGemini = isModelGemini;

package/dist/utils/gemini.d.ts

@@ -0,0 +1,20 @@
+import { BaseMessage, BaseMessageChunk, MessageContent } from "@langchain/core/messages";
+import { ChatGeneration, ChatGenerationChunk, ChatResult, Generation } from "@langchain/core/outputs";
+import type { GoogleLLMResponse, GoogleAIModelParams, GeminiPart, GeminiContent, GenerateContentResponseData } from "../types.js";
+export declare function messageContentToParts(content: MessageContent): GeminiPart[];
+export declare function baseMessageToContent(message: BaseMessage): GeminiContent[];
+export declare function partsToMessageContent(parts: GeminiPart[]): MessageContent;
+export declare function responseToGenerateContentResponseData(response: GoogleLLMResponse): GenerateContentResponseData;
+export declare function responseToParts(response: GoogleLLMResponse): GeminiPart[];
+export declare function partToText(part: GeminiPart): string;
+export declare function responseToString(response: GoogleLLMResponse): string;
+export declare function responseToGeneration(response: GoogleLLMResponse): Generation;
+export declare function responseToChatGeneration(response: GoogleLLMResponse): ChatGenerationChunk;
+export declare function partToMessage(part: GeminiPart): BaseMessageChunk;
+export declare function partToChatGeneration(part: GeminiPart): ChatGeneration;
+export declare function responseToChatGenerations(response: GoogleLLMResponse): ChatGeneration[];
+export declare function responseToMessageContent(response: GoogleLLMResponse): MessageContent;
+export declare function responseToBaseMessage(response: GoogleLLMResponse): BaseMessage;
+export declare function responseToChatResult(response: GoogleLLMResponse): ChatResult;
+export declare function validateGeminiParams(params: GoogleAIModelParams): void;
+export declare function isModelGemini(modelName: string): boolean;

package/dist/utils/gemini.js

@@ -0,0 +1,219 @@
+import { AIMessage, AIMessageChunk, } from "@langchain/core/messages";
+import { ChatGenerationChunk, } from "@langchain/core/outputs";
+function messageContentText(content) {
+    return {
+        text: content.text,
+    };
+}
+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");
+    }
+    if (url.startsWith("data:")) {
+        return {
+            mimeType: url.split(":")[1].split(";")[0],
+            data: url.split(",")[1],
+        };
+    }
+    else {
+        // FIXME - need some way to get mime type
+        return {
+            mimeType: "image/png",
+            fileUri: url,
+        };
+    }
+}
+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) => {
+        // eslint-disable-next-line default-case
+        switch (content.type) {
+            case "text":
+                return messageContentText(content);
+            case "image_url":
+                return messageContentImageUrl(content);
+        }
+    });
+    return parts;
+}
+function roleMessageToContent(role, message) {
+    return [
+        {
+            role,
+            parts: messageContentToParts(message.content),
+        },
+    ];
+}
+function systemMessageToContent(message) {
+    return [
+        ...roleMessageToContent("user", message),
+        ...roleMessageToContent("model", new AIMessage("Ok")),
+    ];
+}
+export function baseMessageToContent(message) {
+    const type = message._getType();
+    switch (type) {
+        case "system":
+            return systemMessageToContent(message);
+        case "human":
+            return roleMessageToContent("user", message);
+        case "ai":
+            return roleMessageToContent("model", message);
+        default:
+            console.log(`Unsupported message type: ${type}`);
+            return [];
+    }
+}
+function textPartToMessageContent(part) {
+    return {
+        type: "text",
+        text: part.text,
+    };
+}
+function inlineDataPartToMessageContent(part) {
+    return {
+        type: "image_url",
+        image_url: `data:${part.mimeType};base64,${part.data}`,
+    };
+}
+function fileDataPartToMessageContent(part) {
+    return {
+        type: "image_url",
+        image_url: part.fileUri,
+    };
+}
+export function partsToMessageContent(parts) {
+    return parts
+        .map((part) => {
+        if ("text" in part) {
+            return textPartToMessageContent(part);
+        }
+        else if ("mimeType" in part && "data" in part) {
+            return inlineDataPartToMessageContent(part);
+        }
+        else if ("mimeType" in part && "fileUri" in part) {
+            return fileDataPartToMessageContent(part);
+        }
+        else {
+            return null;
+        }
+    })
+        .reduce((acc, content) => {
+        if (content) {
+            acc.push(content);
+        }
+        return acc;
+    }, []);
+}
+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;
+    }
+}
+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;
+}
+export function responseToGeneration(response) {
+    return {
+        text: responseToString(response),
+        generationInfo: response,
+    };
+}
+export function responseToChatGeneration(response) {
+    return new ChatGenerationChunk({
+        text: responseToString(response),
+        message: partToMessage(responseToParts(response)[0]),
+        generationInfo: response,
+    });
+}
+export function partToMessage(part) {
+    const content = partsToMessageContent([part]);
+    return new AIMessageChunk({ content });
+}
+export function partToChatGeneration(part) {
+    const message = partToMessage(part);
+    const text = partToText(part);
+    return new ChatGenerationChunk({
+        text,
+        message,
+    });
+}
+export function responseToChatGenerations(response) {
+    const parts = responseToParts(response);
+    const ret = parts.map((part) => partToChatGeneration(part));
+    return ret;
+}
+export function responseToMessageContent(response) {
+    const parts = responseToParts(response);
+    return partsToMessageContent(parts);
+}
+export function responseToBaseMessage(response) {
+    return new AIMessage({
+        content: responseToMessageContent(response),
+    });
+}
+export function responseToChatResult(response) {
+    const generations = responseToChatGenerations(response);
+    return {
+        generations,
+        llmOutput: response,
+    };
+}
+export function validateGeminiParams(params) {
+    if (params.maxOutputTokens && params.maxOutputTokens < 0) {
+        throw new Error("`maxOutputTokens` must be a positive integer");
+    }
+    if (params.temperature &&
+        (params.temperature < 0 || params.temperature > 1)) {
+        throw new Error("`temperature` must be in the range of [0.0,1.0]");
+    }
+    if (params.topP && (params.topP < 0 || params.topP > 1)) {
+        throw new Error("`topP` must be in the range of [0.0,1.0]");
+    }
+    if (params.topK && params.topK < 0) {
+        throw new Error("`topK` must be a positive integer");
+    }
+}
+export function isModelGemini(modelName) {
+    return modelName.toLowerCase().startsWith("gemini");
+}

package/dist/utils/palm.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/palm.d.ts

@@ -0,0 +1,6 @@
+export interface GoogleVertexAIBasePrediction {
+    safetyAttributes?: any;
+}
+export interface GoogleVertexAILLMPredictions<PredictionType extends GoogleVertexAIBasePrediction> {
+    predictions: PredictionType[];
+}

package/dist/utils/palm.js

@@ -0,0 +1 @@
+export {};