@langchain/google-common 0.1.1 → 0.1.3

package/dist/utils/gemini.cjs

@@ -1,10 +1,119 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MessageGeminiSafetyHandler = exports.DefaultGeminiSafetyHandler = exports.isModelGemini = exports.validateGeminiParams = exports.getGeminiAPI = void 0;
+exports.isModelGemini = exports.validateGeminiParams = exports.getGeminiAPI = exports.MessageGeminiSafetyHandler = exports.DefaultGeminiSafetyHandler = void 0;
 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 safety_js_1 = require("./safety.cjs");
+const zod_to_gemini_parameters_js_1 = require("./zod_to_gemini_parameters.cjs");
+class DefaultGeminiSafetyHandler {
+    constructor(settings) {
+        Object.defineProperty(this, "errorFinish", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["SAFETY", "RECITATION", "OTHER"]
+        });
+        this.errorFinish = settings?.errorFinish ?? this.errorFinish;
+    }
+    handleDataPromptFeedback(response, data) {
+        // Check to see if our prompt was blocked in the first place
+        const promptFeedback = data?.promptFeedback;
+        const blockReason = promptFeedback?.blockReason;
+        if (blockReason) {
+            throw new safety_js_1.GoogleAISafetyError(response, `Prompt blocked: ${blockReason}`);
+        }
+        return data;
+    }
+    handleDataFinishReason(response, data) {
+        const firstCandidate = data?.candidates?.[0];
+        const finishReason = firstCandidate?.finishReason;
+        if (this.errorFinish.includes(finishReason)) {
+            throw new safety_js_1.GoogleAISafetyError(response, `Finish reason: ${finishReason}`);
+        }
+        return data;
+    }
+    handleData(response, data) {
+        let ret = data;
+        ret = this.handleDataPromptFeedback(response, ret);
+        ret = this.handleDataFinishReason(response, ret);
+        return ret;
+    }
+    handle(response) {
+        let newdata;
+        if ("nextChunk" in response.data) {
+            // TODO: This is a stream. How to handle?
+            newdata = response.data;
+        }
+        else if (Array.isArray(response.data)) {
+            // If it is an array, try to handle every item in the array
+            try {
+                newdata = response.data.map((item) => this.handleData(response, item));
+            }
+            catch (xx) {
+                // eslint-disable-next-line no-instanceof/no-instanceof
+                if (xx instanceof safety_js_1.GoogleAISafetyError) {
+                    throw new safety_js_1.GoogleAISafetyError(response, xx.message);
+                }
+                else {
+                    throw xx;
+                }
+            }
+        }
+        else {
+            const data = response.data;
+            newdata = this.handleData(response, data);
+        }
+        return {
+            ...response,
+            data: newdata,
+        };
+    }
+}
+exports.DefaultGeminiSafetyHandler = DefaultGeminiSafetyHandler;
+class MessageGeminiSafetyHandler extends DefaultGeminiSafetyHandler {
+    constructor(settings) {
+        super(settings);
+        Object.defineProperty(this, "msg", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "forceNewMessage", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        this.msg = settings?.msg ?? this.msg;
+        this.forceNewMessage = settings?.forceNewMessage ?? this.forceNewMessage;
+    }
+    setMessage(data) {
+        const ret = data;
+        if (this.forceNewMessage ||
+            !data?.candidates?.[0]?.content?.parts?.length) {
+            ret.candidates = data.candidates ?? [];
+            ret.candidates[0] = data.candidates[0] ?? {};
+            ret.candidates[0].content = data.candidates[0].content ?? {};
+            ret.candidates[0].content = {
+                role: "model",
+                parts: [{ text: this.msg }],
+            };
+        }
+        return ret;
+    }
+    handleData(response, data) {
+        try {
+            return super.handleData(response, data);
+        }
+        catch (xx) {
+            return this.setMessage(data);
+        }
+    }
+}
+exports.MessageGeminiSafetyHandler = MessageGeminiSafetyHandler;
 const extractMimeType = (str) => {
     if (str.startsWith("data:")) {
         return {
@@ -85,7 +194,7 @@ function getGeminiAPI(config) {
                 return await blobToFileData(blob);
             }
         }
-        throw new Error("Invalid media content");
+        throw new Error(`Invalid media content: ${JSON.stringify(content, null, 1)}`);
     }
     async function messageContentComplexToPart(content) {
         switch (content.type) {
@@ -103,7 +212,7 @@ function getGeminiAPI(config) {
             case "media":
                 return await messageContentMedia(content);
             default:
-                throw new Error(`Unsupported type received while converting message to message parts`);
+                throw new Error(`Unsupported type "${content.type}" received while converting message to message parts: ${content}`);
         }
         throw new Error(`Cannot coerce "${content.type}" message part into a string.`);
     }
@@ -181,8 +290,8 @@ function getGeminiAPI(config) {
             },
         ];
     }
-    async function systemMessageToContent(message, useSystemInstruction) {
-        return useSystemInstruction
+    async function systemMessageToContent(message) {
+        return config?.useSystemInstruction
             ? roleMessageToContent("system", message)
             : [
                 ...(await roleMessageToContent("user", message)),
@@ -236,11 +345,11 @@ function getGeminiAPI(config) {
             ];
         }
     }
-    async function baseMessageToContent(message, prevMessage, useSystemInstruction) {
+    async function baseMessageToContent(message, prevMessage) {
         const type = message._getType();
         switch (type) {
             case "system":
-                return systemMessageToContent(message, useSystemInstruction);
+                return systemMessageToContent(message);
             case "human":
                 return roleMessageToContent("user", message);
             case "ai":
@@ -378,7 +487,8 @@ function getGeminiAPI(config) {
         }, "");
         return ret;
     }
-    function safeResponseTo(response, safetyHandler, responseTo) {
+    function safeResponseTo(response, responseTo) {
+        const safetyHandler = config?.safetyHandler ?? new DefaultGeminiSafetyHandler();
         try {
             const safeResponse = safetyHandler.handle(response);
             return responseTo(safeResponse);
@@ -392,8 +502,8 @@ function getGeminiAPI(config) {
             throw xx;
         }
     }
-    function safeResponseToString(response, safetyHandler) {
-        return safeResponseTo(response, safetyHandler, responseToString);
+    function safeResponseToString(response) {
+        return safeResponseTo(response, responseToString);
     }
     function responseToGenerationInfo(response) {
         if (!Array.isArray(response.data)) {
@@ -423,8 +533,8 @@ function getGeminiAPI(config) {
             generationInfo: responseToGenerationInfo(response),
         });
     }
-    function safeResponseToChatGeneration(response, safetyHandler) {
-        return safeResponseTo(response, safetyHandler, responseToChatGeneration);
+    function safeResponseToChatGeneration(response) {
+        return safeResponseTo(response, responseToChatGeneration);
     }
     function chunkToString(chunk) {
         if (chunk === null) {
@@ -556,8 +666,8 @@ function getGeminiAPI(config) {
         const fields = responseToBaseMessageFields(response);
         return new messages_1.AIMessage(fields);
     }
-    function safeResponseToBaseMessage(response, safetyHandler) {
-        return safeResponseTo(response, safetyHandler, responseToBaseMessage);
+    function safeResponseToBaseMessage(response) {
+        return safeResponseTo(response, responseToBaseMessage);
     }
     function responseToChatResult(response) {
         const generations = responseToChatGenerations(response);
@@ -566,17 +676,190 @@ function getGeminiAPI(config) {
             llmOutput: responseToGenerationInfo(response),
         };
     }
-    function safeResponseToChatResult(response, safetyHandler) {
-        return safeResponseTo(response, safetyHandler, responseToChatResult);
+    function safeResponseToChatResult(response) {
+        return safeResponseTo(response, responseToChatResult);
+    }
+    function inputType(input) {
+        if (typeof input === "string") {
+            return "MessageContent";
+        }
+        else {
+            const firstItem = input[0];
+            if (Object.hasOwn(firstItem, "content")) {
+                return "BaseMessageArray";
+            }
+            else {
+                return "MessageContent";
+            }
+        }
+    }
+    async function formatMessageContents(input, _parameters) {
+        const parts = await messageContentToParts(input);
+        const contents = [
+            {
+                role: "user",
+                parts,
+            },
+        ];
+        return contents;
+    }
+    async function formatBaseMessageContents(input, _parameters) {
+        const inputPromises = input.map((msg, i) => baseMessageToContent(msg, input[i - 1]));
+        const inputs = await Promise.all(inputPromises);
+        return inputs.reduce((acc, cur) => {
+            // Filter out the system content
+            if (cur.every((content) => content.role === "system")) {
+                return acc;
+            }
+            // Combine adjacent function messages
+            if (cur[0]?.role === "function" &&
+                acc.length > 0 &&
+                acc[acc.length - 1].role === "function") {
+                acc[acc.length - 1].parts = [
+                    ...acc[acc.length - 1].parts,
+                    ...cur[0].parts,
+                ];
+            }
+            else {
+                acc.push(...cur);
+            }
+            return acc;
+        }, []);
+    }
+    async function formatContents(input, parameters) {
+        const it = inputType(input);
+        switch (it) {
+            case "MessageContent":
+                return formatMessageContents(input, parameters);
+            case "BaseMessageArray":
+                return formatBaseMessageContents(input, parameters);
+            default:
+                throw new Error(`Unknown input type "${it}": ${input}`);
+        }
+    }
+    function formatGenerationConfig(parameters) {
+        return {
+            temperature: parameters.temperature,
+            topK: parameters.topK,
+            topP: parameters.topP,
+            maxOutputTokens: parameters.maxOutputTokens,
+            stopSequences: parameters.stopSequences,
+            responseMimeType: parameters.responseMimeType,
+        };
+    }
+    function formatSafetySettings(parameters) {
+        return parameters.safetySettings ?? [];
+    }
+    async function formatBaseMessageSystemInstruction(input) {
+        let ret = {};
+        for (let index = 0; index < input.length; index += 1) {
+            const message = input[index];
+            if (message._getType() === "system") {
+                // For system types, we only want it if it is the first message,
+                // if it appears anywhere else, it should be an error.
+                if (index === 0) {
+                    // eslint-disable-next-line prefer-destructuring
+                    ret = (await baseMessageToContent(message, undefined))[0];
+                }
+                else {
+                    throw new Error("System messages are only permitted as the first passed message.");
+                }
+            }
+        }
+        return ret;
+    }
+    async function formatSystemInstruction(input) {
+        if (!config?.useSystemInstruction) {
+            return {};
+        }
+        const it = inputType(input);
+        switch (it) {
+            case "BaseMessageArray":
+                return formatBaseMessageSystemInstruction(input);
+            default:
+                return {};
+        }
+    }
+    function structuredToolToFunctionDeclaration(tool) {
+        const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+        return {
+            name: tool.name,
+            description: tool.description ?? `A function available to call.`,
+            parameters: jsonSchema,
+        };
+    }
+    function structuredToolsToGeminiTools(tools) {
+        return [
+            {
+                functionDeclarations: tools.map(structuredToolToFunctionDeclaration),
+            },
+        ];
+    }
+    function formatTools(parameters) {
+        const tools = parameters?.tools;
+        if (!tools || tools.length === 0) {
+            return [];
+        }
+        if (tools.every(function_calling_1.isLangChainTool)) {
+            return structuredToolsToGeminiTools(tools);
+        }
+        else {
+            if (tools.length === 1 &&
+                (!("functionDeclarations" in tools[0]) ||
+                    !tools[0].functionDeclarations?.length)) {
+                return [];
+            }
+            return tools;
+        }
+    }
+    function formatToolConfig(parameters) {
+        if (!parameters.tool_choice || typeof parameters.tool_choice !== "string") {
+            return undefined;
+        }
+        return {
+            functionCallingConfig: {
+                mode: parameters.tool_choice,
+                allowedFunctionNames: parameters.allowed_function_names,
+            },
+        };
+    }
+    async function formatData(input, parameters) {
+        const typedInput = input;
+        const contents = await formatContents(typedInput, parameters);
+        const generationConfig = formatGenerationConfig(parameters);
+        const tools = formatTools(parameters);
+        const toolConfig = formatToolConfig(parameters);
+        const safetySettings = formatSafetySettings(parameters);
+        const systemInstruction = await formatSystemInstruction(typedInput);
+        const ret = {
+            contents,
+            generationConfig,
+        };
+        if (tools && tools.length) {
+            ret.tools = tools;
+        }
+        if (toolConfig) {
+            ret.toolConfig = toolConfig;
+        }
+        if (safetySettings && safetySettings.length) {
+            ret.safetySettings = safetySettings;
+        }
+        if (systemInstruction?.role &&
+            systemInstruction?.parts &&
+            systemInstruction?.parts?.length) {
+            ret.systemInstruction = systemInstruction;
+        }
+        return ret;
     }
     return {
         messageContentToParts,
         baseMessageToContent,
-        safeResponseToString,
-        safeResponseToChatGeneration,
+        responseToString: safeResponseToString,
+        responseToChatGeneration: safeResponseToChatGeneration,
         chunkToString,
-        safeResponseToBaseMessage,
-        safeResponseToChatResult,
+        responseToBaseMessage: safeResponseToBaseMessage,
+        responseToChatResult: safeResponseToChatResult,
+        formatData,
     };
 }
 exports.getGeminiAPI = getGeminiAPI;
@@ -600,110 +883,3 @@ function isModelGemini(modelName) {
     return modelName.toLowerCase().startsWith("gemini");
 }
 exports.isModelGemini = isModelGemini;
-class DefaultGeminiSafetyHandler {
-    constructor(settings) {
-        Object.defineProperty(this, "errorFinish", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["SAFETY", "RECITATION", "OTHER"]
-        });
-        this.errorFinish = settings?.errorFinish ?? this.errorFinish;
-    }
-    handleDataPromptFeedback(response, data) {
-        // Check to see if our prompt was blocked in the first place
-        const promptFeedback = data?.promptFeedback;
-        const blockReason = promptFeedback?.blockReason;
-        if (blockReason) {
-            throw new safety_js_1.GoogleAISafetyError(response, `Prompt blocked: ${blockReason}`);
-        }
-        return data;
-    }
-    handleDataFinishReason(response, data) {
-        const firstCandidate = data?.candidates?.[0];
-        const finishReason = firstCandidate?.finishReason;
-        if (this.errorFinish.includes(finishReason)) {
-            throw new safety_js_1.GoogleAISafetyError(response, `Finish reason: ${finishReason}`);
-        }
-        return data;
-    }
-    handleData(response, data) {
-        let ret = data;
-        ret = this.handleDataPromptFeedback(response, ret);
-        ret = this.handleDataFinishReason(response, ret);
-        return ret;
-    }
-    handle(response) {
-        let newdata;
-        if ("nextChunk" in response.data) {
-            // TODO: This is a stream. How to handle?
-            newdata = response.data;
-        }
-        else if (Array.isArray(response.data)) {
-            // If it is an array, try to handle every item in the array
-            try {
-                newdata = response.data.map((item) => this.handleData(response, item));
-            }
-            catch (xx) {
-                // eslint-disable-next-line no-instanceof/no-instanceof
-                if (xx instanceof safety_js_1.GoogleAISafetyError) {
-                    throw new safety_js_1.GoogleAISafetyError(response, xx.message);
-                }
-                else {
-                    throw xx;
-                }
-            }
-        }
-        else {
-            const data = response.data;
-            newdata = this.handleData(response, data);
-        }
-        return {
-            ...response,
-            data: newdata,
-        };
-    }
-}
-exports.DefaultGeminiSafetyHandler = DefaultGeminiSafetyHandler;
-class MessageGeminiSafetyHandler extends DefaultGeminiSafetyHandler {
-    constructor(settings) {
-        super(settings);
-        Object.defineProperty(this, "msg", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ""
-        });
-        Object.defineProperty(this, "forceNewMessage", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.msg = settings?.msg ?? this.msg;
-        this.forceNewMessage = settings?.forceNewMessage ?? this.forceNewMessage;
-    }
-    setMessage(data) {
-        const ret = data;
-        if (this.forceNewMessage ||
-            !data?.candidates?.[0]?.content?.parts?.length) {
-            ret.candidates = data.candidates ?? [];
-            ret.candidates[0] = data.candidates[0] ?? {};
-            ret.candidates[0].content = data.candidates[0].content ?? {};
-            ret.candidates[0].content = {
-                role: "model",
-                parts: [{ text: this.msg }],
-            };
-        }
-        return ret;
-    }
-    handleData(response, data) {
-        try {
-            return super.handleData(response, data);
-        }
-        catch (xx) {
-            return this.setMessage(data);
-        }
-    }
-}
-exports.MessageGeminiSafetyHandler = MessageGeminiSafetyHandler;

package/dist/utils/gemini.d.ts

@@ -1,6 +1,4 @@
-import { BaseMessage, BaseMessageChunk, MessageContent } from "@langchain/core/messages";
-import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
-import type { GoogleLLMResponse, GoogleAIModelParams, GeminiPart, GeminiContent, GenerateContentResponseData, GoogleAISafetyHandler, GeminiAPIConfig } from "../types.js";
+import type { GoogleLLMResponse, GoogleAIModelParams, GenerateContentResponseData, GoogleAISafetyHandler, GoogleAIAPI, GeminiAPIConfig } from "../types.js";
 export interface FunctionCall {
     name: string;
     arguments: string;
@@ -19,17 +17,6 @@ export interface ToolCallRaw {
     type: "function";
     function: FunctionCallRaw;
 }
-export declare function getGeminiAPI(config?: GeminiAPIConfig): {
-    messageContentToParts: (content: MessageContent) => Promise<GeminiPart[]>;
-    baseMessageToContent: (message: BaseMessage, prevMessage: BaseMessage | undefined, useSystemInstruction: boolean) => Promise<GeminiContent[]>;
-    safeResponseToString: (response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler) => string;
-    safeResponseToChatGeneration: (response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler) => ChatGenerationChunk;
-    chunkToString: (chunk: BaseMessageChunk) => string;
-    safeResponseToBaseMessage: (response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler) => BaseMessage;
-    safeResponseToChatResult: (response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler) => ChatResult;
-};
-export declare function validateGeminiParams(params: GoogleAIModelParams): void;
-export declare function isModelGemini(modelName: string): boolean;
 export interface DefaultGeminiSafetySettings {
     errorFinish?: string[];
 }
@@ -52,3 +39,6 @@ export declare class MessageGeminiSafetyHandler extends DefaultGeminiSafetyHandl
     setMessage(data: GenerateContentResponseData): GenerateContentResponseData;
     handleData(response: GoogleLLMResponse, data: GenerateContentResponseData): GenerateContentResponseData;
 }
+export declare function getGeminiAPI(config?: GeminiAPIConfig): GoogleAIAPI;
+export declare function validateGeminiParams(params: GoogleAIModelParams): void;
+export declare function isModelGemini(modelName: string): boolean;