@langchain/google-common 0.0.0 → 0.0.2

package/dist/utils/gemini.js

@@ -1,9 +1,15 @@
 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,
-    };
+    if (content?.text && content?.text.length > 0) {
+        return {
+            text: content.text,
+        };
+    }
+    else {
+        return null;
+    }
 }
 function messageContentImageUrl(content) {
     const url = typeof content.image_url === "string"
@@ -14,15 +20,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,
+            },
         };
     }
 }
@@ -37,22 +47,60 @@ export function messageContentToParts(content) {
         ]
         : content;
     // eslint-disable-next-line array-callback-return
-    const parts = messageContent.map((content) => {
-        // eslint-disable-next-line default-case
+    const parts = messageContent
+        .map((content) => {
         switch (content.type) {
             case "text":
                 return messageContentText(content);
             case "image_url":
                 return messageContentImageUrl(content);
+            default:
+                throw new Error(`Unsupported type received while converting message to message parts`);
         }
-    });
+    })
+        .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;
+}
 function roleMessageToContent(role, message) {
+    const contentParts = messageContentToParts(message.content);
+    const toolParts = messageKwargsToParts(message.additional_kwargs);
+    const parts = [...contentParts, ...toolParts];
     return [
         {
             role,
-            parts: messageContentToParts(message.content),
+            parts,
         },
     ];
 }
@@ -62,6 +110,32 @@ function systemMessageToContent(message) {
         ...roleMessageToContent("model", new AIMessage("Ok")),
     ];
 }
+function toolMessageToContent(message) {
+    const contentStr = typeof message.content === "string"
+        ? message.content
+        : message.content.reduce((acc, content) => {
+            if (content.type === "text") {
+                return acc + content.text;
+            }
+            else {
+                return acc;
+            }
+        }, "");
+    const content = JSON.parse(contentStr);
+    return [
+        {
+            role: "function",
+            parts: [
+                {
+                    functionResponse: {
+                        name: message.tool_call_id,
+                        response: content,
+                    },
+                },
+            ],
+        },
+    ];
+}
 export function baseMessageToContent(message) {
     const type = message._getType();
     switch (type) {
@@ -71,6 +145,8 @@ export function baseMessageToContent(message) {
             return roleMessageToContent("user", message);
         case "ai":
             return roleMessageToContent("model", message);
+        case "tool":
+            return toolMessageToContent(message);
         default:
             console.log(`Unsupported message type: ${type}`);
             return [];
@@ -85,25 +161,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 {
@@ -117,6 +196,49 @@ export function partsToMessageContent(parts) {
         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: part?.functionCall?.name ?? "",
+        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;
+        }
+        else if ("functionCall" in part) {
+            return functionCallPartToToolRaw(part);
+        }
+        else {
+            return null;
+        }
+    })
+        .reduce((acc, content) => {
+        if (content) {
+            acc.push(content);
+        }
+        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");
@@ -153,12 +275,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,9 +308,29 @@ 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 });
+    const fields = partsToBaseMessageFields([part]);
+    return new AIMessageChunk(fields);
 }
 export function partToChatGeneration(part) {
     const message = partToMessage(part);
@@ -183,14 +345,29 @@ export function responseToChatGenerations(response) {
     const ret = parts.map((part) => partToChatGeneration(part));
     return ret;
 }
-export function responseToMessageContent(response) {
+export function responseToBaseMessageFields(response) {
     const parts = responseToParts(response);
-    return partsToMessageContent(parts);
+    return partsToBaseMessageFields(parts);
+}
+export function partsToBaseMessageFields(parts) {
+    const fields = {
+        content: partsToMessageContent(parts),
+    };
+    const rawTools = partsToToolsRaw(parts);
+    if (rawTools.length > 0) {
+        const tools = toolsRawToTools(rawTools);
+        fields.additional_kwargs = {
+            tool_calls: tools,
+        };
+    }
+    return fields;
 }
 export function responseToBaseMessage(response) {
-    return new AIMessage({
-        content: responseToMessageContent(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);
@@ -199,6 +376,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 +397,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/index.cjs

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./common.cjs"), exports);
+__exportStar(require("./failed_handler.cjs"), exports);
+__exportStar(require("./gemini.cjs"), exports);
+__exportStar(require("./zod_to_gemini_parameters.cjs"), exports);
+__exportStar(require("./palm.cjs"), exports);
+__exportStar(require("./safety.cjs"), exports);
+__exportStar(require("./stream.cjs"), exports);

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./common.js";
+export * from "./failed_handler.js";
+export * from "./gemini.js";
+export * from "./zod_to_gemini_parameters.js";
+export * from "./palm.js";
+export * from "./safety.js";
+export * from "./stream.js";

package/dist/utils/index.js

@@ -0,0 +1,7 @@
+export * from "./common.js";
+export * from "./failed_handler.js";
+export * from "./gemini.js";
+export * from "./zod_to_gemini_parameters.js";
+export * from "./palm.js";
+export * from "./safety.js";
+export * from "./stream.js";

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/dist/utils/zod_to_gemini_parameters.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zodToGeminiParameters = void 0;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+function zodToGeminiParameters(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+zodObj) {
+    // Gemini doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const jsonSchema = (0, zod_to_json_schema_1.zodToJsonSchema)(zodObj);
+    const { $schema, additionalProperties, ...rest } = jsonSchema;
+    return rest;
+}
+exports.zodToGeminiParameters = zodToGeminiParameters;

package/dist/utils/zod_to_gemini_parameters.d.ts

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import { GeminiFunctionSchema } from "../types.js";
+export declare function zodToGeminiParameters(zodObj: z.ZodType<any>): GeminiFunctionSchema;

package/dist/utils/zod_to_gemini_parameters.js

@@ -0,0 +1,11 @@
+import { zodToJsonSchema } from "zod-to-json-schema";
+export function zodToGeminiParameters(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+zodObj) {
+    // Gemini doesn't accept either the $schema or additionalProperties
+    // attributes, so we need to explicitly remove them.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const jsonSchema = zodToJsonSchema(zodObj);
+    const { $schema, additionalProperties, ...rest } = jsonSchema;
+    return rest;
+}

package/index.d.cts

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/google-common",
-  "version": "0.0.0",
+  "version": "0.0.2",
   "description": "Core types and classes for Google services.",
   "type": "module",
   "engines": {
@@ -12,6 +12,7 @@
     "type": "git",
     "url": "git@github.com:langchain-ai/langchainjs.git"
   },
+  "homepage": "https://github.com/langchain-ai/langchainjs/tree/main/libs/langchain-google-common/",
   "scripts": {
     "build": "yarn run build:deps && yarn clean && yarn build:esm && yarn build:cjs && yarn build:scripts",
     "build:deps": "yarn run turbo:command build --filter=@langchain/core",
@@ -23,7 +24,7 @@
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",
-    "clean": "rm -rf dist/ && NODE_OPTIONS=--max-old-space-size=4096 yarn create-entrypoints -- --pre",
+    "clean": "rm -rf dist/ && NODE_OPTIONS=--max-old-space-size=4096 yarn lc-build --config ./langchain.config.js --create-entrypoints --pre",
     "prepack": "yarn build",
     "test": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules jest --testPathIgnorePatterns=\\.int\\.test.ts --testTimeout 30000 --maxWorkers=50%",
     "test:watch": "yarn run build:deps && NODE_OPTIONS=--experimental-vm-modules jest --watch --testPathIgnorePatterns=\\.int\\.test.ts",
@@ -38,11 +39,12 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": "~0.1.1"
+    "@langchain/core": "~0.1.1",
+    "zod-to-json-schema": "^3.22.4"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",
-    "@langchain/scripts": "^0.0.2",
+    "@langchain/scripts": "~0.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",
@@ -59,25 +61,58 @@
     "jest": "^29.5.0",
     "jest-environment-node": "^29.6.4",
     "prettier": "^2.8.3",
+    "release-it": "^15.10.1",
     "rollup": "^4.5.2",
     "ts-jest": "^29.1.0",
-    "typescript": "<5.2.0"
+    "typescript": "<5.2.0",
+    "zod": "^3.22.4"
   },
   "publishConfig": {
     "access": "public"
   },
   "exports": {
     ".": {
-      "types": "./index.d.ts",
+      "types": {
+        "import": "./index.d.ts",
+        "require": "./index.d.cts",
+        "default": "./index.d.ts"
+      },
       "import": "./index.js",
       "require": "./index.cjs"
     },
+    "./utils": {
+      "types": {
+        "import": "./utils.d.ts",
+        "require": "./utils.d.cts",
+        "default": "./utils.d.ts"
+      },
+      "import": "./utils.js",
+      "require": "./utils.cjs"
+    },
+    "./types": {
+      "types": {
+        "import": "./types.d.ts",
+        "require": "./types.d.cts",
+        "default": "./types.d.ts"
+      },
+      "import": "./types.js",
+      "require": "./types.cjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
     "dist/",
     "index.cjs",
     "index.js",
-    "index.d.ts"
+    "index.d.ts",
+    "index.d.cts",
+    "utils.cjs",
+    "utils.js",
+    "utils.d.ts",
+    "utils.d.cts",
+    "types.cjs",
+    "types.js",
+    "types.d.ts",
+    "types.d.cts"
   ]
 }

package/types.cjs

@@ -0,0 +1 @@
+module.exports = require('./dist/types.cjs');

package/types.d.cts

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