@langchain/google-common 0.0.0 → 0.0.1

package/dist/utils/failed_handler.js

@@ -0,0 +1,32 @@
+const STATUS_NO_RETRY = [
+    400,
+    401,
+    402,
+    403,
+    404,
+    405,
+    406,
+    407,
+    408,
+    409, // Conflict
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function failedAttemptHandler(error) {
+    const status = error?.response?.status ?? 0;
+    if (status === 0) {
+        // What is this?
+        console.error("failedAttemptHandler", error);
+    }
+    // What errors shouldn't be retried?
+    if (STATUS_NO_RETRY.includes(+status)) {
+        throw error;
+    }
+    throw error;
+}
+export function ensureParams(params) {
+    const base = params ?? {};
+    return {
+        onFailedAttempt: failedAttemptHandler,
+        ...base,
+    };
+}

package/dist/utils/gemini.cjs

@@ -1,8 +1,9 @@
 "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;
+exports.MessageGeminiSafetyHandler = exports.DefaultGeminiSafetyHandler = exports.isModelGemini = exports.validateGeminiParams = exports.safeResponseToChatResult = exports.responseToChatResult = exports.safeResponseToBaseMessage = exports.responseToBaseMessage = exports.responseToMessageContent = exports.responseToChatGenerations = exports.partToChatGeneration = exports.partToMessage = exports.chunkToString = exports.safeResponseToChatGeneration = exports.responseToChatGeneration = exports.safeResponseToGeneration = exports.responseToGeneration = exports.safeResponseToString = 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");
+const safety_js_1 = require("./safety.cjs");
 function messageContentText(content) {
     return {
         text: content.text,
@@ -17,15 +18,19 @@ function messageContentImageUrl(content) {
     }
     if (url.startsWith("data:")) {
         return {
-            mimeType: url.split(":")[1].split(";")[0],
-            data: url.split(",")[1],
+            inlineData: {
+                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,
+            fileData: {
+                mimeType: "image/png",
+                fileUri: url,
+            },
         };
     }
 }
@@ -90,25 +95,28 @@ function textPartToMessageContent(part) {
 function inlineDataPartToMessageContent(part) {
     return {
         type: "image_url",
-        image_url: `data:${part.mimeType};base64,${part.data}`,
+        image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
     };
 }
 function fileDataPartToMessageContent(part) {
     return {
         type: "image_url",
-        image_url: part.fileUri,
+        image_url: part.fileData.fileUri,
     };
 }
 function partsToMessageContent(parts) {
     return parts
         .map((part) => {
-        if ("text" in part) {
+        if (part === undefined || part === null) {
+            return null;
+        }
+        else if ("text" in part) {
             return textPartToMessageContent(part);
         }
-        else if ("mimeType" in part && "data" in part) {
+        else if ("inlineData" in part) {
             return inlineDataPartToMessageContent(part);
         }
-        else if ("mimeType" in part && "fileUri" in part) {
+        else if ("fileData" in part) {
             return fileDataPartToMessageContent(part);
         }
         else {
@@ -163,6 +171,24 @@ function responseToString(response) {
     return ret;
 }
 exports.responseToString = responseToString;
+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 safety_js_1.GoogleAISafetyError) {
+            const ret = responseTo(xx.response);
+            xx.reply = ret;
+        }
+        throw xx;
+    }
+}
+function safeResponseToString(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToString);
+}
+exports.safeResponseToString = safeResponseToString;
 function responseToGeneration(response) {
     return {
         text: responseToString(response),
@@ -170,6 +196,10 @@ function responseToGeneration(response) {
     };
 }
 exports.responseToGeneration = responseToGeneration;
+function safeResponseToGeneration(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToGeneration);
+}
+exports.safeResponseToGeneration = safeResponseToGeneration;
 function responseToChatGeneration(response) {
     return new outputs_1.ChatGenerationChunk({
         text: responseToString(response),
@@ -178,6 +208,28 @@ function responseToChatGeneration(response) {
     });
 }
 exports.responseToChatGeneration = responseToChatGeneration;
+function safeResponseToChatGeneration(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToChatGeneration);
+}
+exports.safeResponseToChatGeneration = safeResponseToChatGeneration;
+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}`);
+    }
+}
+exports.chunkToString = chunkToString;
 function partToMessage(part) {
     const content = partsToMessageContent([part]);
     return new messages_1.AIMessageChunk({ content });
@@ -209,6 +261,10 @@ function responseToBaseMessage(response) {
     });
 }
 exports.responseToBaseMessage = responseToBaseMessage;
+function safeResponseToBaseMessage(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToBaseMessage);
+}
+exports.safeResponseToBaseMessage = safeResponseToBaseMessage;
 function responseToChatResult(response) {
     const generations = responseToChatGenerations(response);
     return {
@@ -217,6 +273,10 @@ function responseToChatResult(response) {
     };
 }
 exports.responseToChatResult = responseToChatResult;
+function safeResponseToChatResult(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToChatResult);
+}
+exports.safeResponseToChatResult = safeResponseToChatResult;
 function validateGeminiParams(params) {
     if (params.maxOutputTokens && params.maxOutputTokens < 0) {
         throw new Error("`maxOutputTokens` must be a positive integer");
@@ -237,3 +297,110 @@ 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,6 @@
 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";
+import type { GoogleLLMResponse, GoogleAIModelParams, GeminiPart, GeminiContent, GenerateContentResponseData, GoogleAISafetyHandler } from "../types.js";
 export declare function messageContentToParts(content: MessageContent): GeminiPart[];
 export declare function baseMessageToContent(message: BaseMessage): GeminiContent[];
 export declare function partsToMessageContent(parts: GeminiPart[]): MessageContent;
@@ -8,13 +8,41 @@ export declare function responseToGenerateContentResponseData(response: GoogleLL
 export declare function responseToParts(response: GoogleLLMResponse): GeminiPart[];
 export declare function partToText(part: GeminiPart): string;
 export declare function responseToString(response: GoogleLLMResponse): string;
+export declare function safeResponseToString(response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler): string;
 export declare function responseToGeneration(response: GoogleLLMResponse): Generation;
+export declare function safeResponseToGeneration(response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler): Generation;
 export declare function responseToChatGeneration(response: GoogleLLMResponse): ChatGenerationChunk;
+export declare function safeResponseToChatGeneration(response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler): ChatGenerationChunk;
+export declare function chunkToString(chunk: BaseMessageChunk): string;
 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 safeResponseToBaseMessage(response: GoogleLLMResponse, safetyHandler: GoogleAISafetyHandler): BaseMessage;
 export declare function responseToChatResult(response: GoogleLLMResponse): ChatResult;
+export declare function 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[];
+}
+export declare class DefaultGeminiSafetyHandler implements GoogleAISafetyHandler {
+    errorFinish: string[];
+    constructor(settings?: DefaultGeminiSafetySettings);
+    handleDataPromptFeedback(response: GoogleLLMResponse, data: GenerateContentResponseData): GenerateContentResponseData;
+    handleDataFinishReason(response: GoogleLLMResponse, data: GenerateContentResponseData): GenerateContentResponseData;
+    handleData(response: GoogleLLMResponse, data: GenerateContentResponseData): GenerateContentResponseData;
+    handle(response: GoogleLLMResponse): GoogleLLMResponse;
+}
+export interface MessageGeminiSafetySettings extends DefaultGeminiSafetySettings {
+    msg?: string;
+    forceNewMessage?: boolean;
+}
+export declare class MessageGeminiSafetyHandler extends DefaultGeminiSafetyHandler {
+    msg: string;
+    forceNewMessage: boolean;
+    constructor(settings?: MessageGeminiSafetySettings);
+    setMessage(data: GenerateContentResponseData): GenerateContentResponseData;
+    handleData(response: GoogleLLMResponse, data: GenerateContentResponseData): GenerateContentResponseData;
+}

package/dist/utils/gemini.js

@@ -1,5 +1,6 @@
 import { AIMessage, AIMessageChunk, } from "@langchain/core/messages";
 import { ChatGenerationChunk, } from "@langchain/core/outputs";
+import { GoogleAISafetyError } from "./safety.js";
 function messageContentText(content) {
     return {
         text: content.text,
@@ -14,15 +15,19 @@ function messageContentImageUrl(content) {
     }
     if (url.startsWith("data:")) {
         return {
-            mimeType: url.split(":")[1].split(";")[0],
-            data: url.split(",")[1],
+            inlineData: {
+                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,
+            fileData: {
+                mimeType: "image/png",
+                fileUri: url,
+            },
         };
     }
 }
@@ -85,25 +90,28 @@ function textPartToMessageContent(part) {
 function inlineDataPartToMessageContent(part) {
     return {
         type: "image_url",
-        image_url: `data:${part.mimeType};base64,${part.data}`,
+        image_url: `data:${part.inlineData.mimeType};base64,${part.inlineData.data}`,
     };
 }
 function fileDataPartToMessageContent(part) {
     return {
         type: "image_url",
-        image_url: part.fileUri,
+        image_url: part.fileData.fileUri,
     };
 }
 export function partsToMessageContent(parts) {
     return parts
         .map((part) => {
-        if ("text" in part) {
+        if (part === undefined || part === null) {
+            return null;
+        }
+        else if ("text" in part) {
             return textPartToMessageContent(part);
         }
-        else if ("mimeType" in part && "data" in part) {
+        else if ("inlineData" in part) {
             return inlineDataPartToMessageContent(part);
         }
-        else if ("mimeType" in part && "fileUri" in part) {
+        else if ("fileData" in part) {
             return fileDataPartToMessageContent(part);
         }
         else {
@@ -153,12 +161,32 @@ export function responseToString(response) {
     }, "");
     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;
+    }
+}
+export function safeResponseToString(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToString);
+}
 export function responseToGeneration(response) {
     return {
         text: responseToString(response),
         generationInfo: response,
     };
 }
+export function safeResponseToGeneration(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToGeneration);
+}
 export function responseToChatGeneration(response) {
     return new ChatGenerationChunk({
         text: responseToString(response),
@@ -166,6 +194,26 @@ export function responseToChatGeneration(response) {
         generationInfo: 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;
+    }
+    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 partToMessage(part) {
     const content = partsToMessageContent([part]);
     return new AIMessageChunk({ content });
@@ -192,6 +240,9 @@ export function responseToBaseMessage(response) {
         content: responseToMessageContent(response),
     });
 }
+export function safeResponseToBaseMessage(response, safetyHandler) {
+    return safeResponseTo(response, safetyHandler, responseToBaseMessage);
+}
 export function responseToChatResult(response) {
     const generations = responseToChatGenerations(response);
     return {
@@ -199,6 +250,9 @@ export function responseToChatResult(response) {
         llmOutput: response,
     };
 }
+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");
@@ -217,3 +271,108 @@ export function validateGeminiParams(params) {
 export function isModelGemini(modelName) {
     return modelName.toLowerCase().startsWith("gemini");
 }
+export 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 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 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 GoogleAISafetyError) {
+                    throw new GoogleAISafetyError(response, xx.message);
+                }
+                else {
+                    throw xx;
+                }
+            }
+        }
+        else {
+            const data = response.data;
+            newdata = this.handleData(response, data);
+        }
+        return {
+            ...response,
+            data: newdata,
+        };
+    }
+}
+export 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);
+        }
+    }
+}

package/dist/utils/safety.cjs

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleAISafetyError = void 0;
+class GoogleAISafetyError extends Error {
+    constructor(response, message) {
+        super(message);
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "reply", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        this.response = response;
+    }
+}
+exports.GoogleAISafetyError = GoogleAISafetyError;

package/dist/utils/safety.d.ts

@@ -0,0 +1,6 @@
+import { GoogleLLMResponse } from "../types.js";
+export declare class GoogleAISafetyError extends Error {
+    response: GoogleLLMResponse;
+    reply: any;
+    constructor(response: GoogleLLMResponse, message?: string);
+}

package/dist/utils/safety.js

@@ -0,0 +1,19 @@
+export class GoogleAISafetyError extends Error {
+    constructor(response, message) {
+        super(message);
+        Object.defineProperty(this, "response", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "reply", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        this.response = response;
+    }
+}

package/index.d.cts

@@ -0,0 +1 @@
+export * from './dist/index.js'