@langchain/google-common 0.0.0 → 0.0.1

package/dist/chat_models.cjs

@@ -9,6 +9,7 @@ const common_js_1 = require("./utils/common.cjs");
 const connection_js_1 = require("./connection.cjs");
 const gemini_js_1 = require("./utils/gemini.cjs");
 const auth_js_1 = require("./auth.cjs");
+const failed_handler_js_1 = require("./utils/failed_handler.cjs");
 class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         return input
@@ -25,7 +26,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         return "ChatGoogle";
     }
     constructor(fields) {
-        super(fields ?? {});
+        super((0, failed_handler_js_1.ensureParams)(fields));
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -74,6 +75,12 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "safetyHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -87,6 +94,8 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             value: void 0
         });
         (0, common_js_1.copyAndValidateModelParamsInto)(fields, this);
+        this.safetyHandler =
+            fields?.safetyHandler ?? new gemini_js_1.DefaultGeminiSafetyHandler();
         const client = this.buildClient(fields);
         this.buildConnection(fields ?? {}, client);
     }
@@ -119,7 +128,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
     async _generate(messages, options, _runManager) {
         const parameters = (0, common_js_1.copyAIModelParams)(this);
         const response = await this.connection.request(messages, parameters, options);
-        const ret = (0, gemini_js_1.responseToChatResult)(response);
+        const ret = (0, gemini_js_1.safeResponseToChatResult)(response, this.safetyHandler);
         return ret;
     }
     async *_streamResponseChunks(_messages, _options, _runManager) {
@@ -134,7 +143,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         while (!stream.streamDone) {
             const output = await stream.nextChunk();
             const chunk = output !== null
-                ? (0, gemini_js_1.responseToChatGeneration)({ data: output })
+                ? (0, gemini_js_1.safeResponseToChatGeneration)({ data: output }, this.safetyHandler)
                 : new outputs_1.ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },

package/dist/chat_models.d.ts

@@ -6,14 +6,14 @@ import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
 import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent } from "./types.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAbstractedClient } from "./auth.js";
-import { GoogleBaseLLMInput } from "./llms.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams } from "./types.js";
 declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
     formatContents(input: BaseMessage[], _parameters: GoogleAIModelParams): GeminiContent[];
 }
 /**
  * Input to chat model class.
  */
-export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams {
+export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams {
 }
 /**
  * Integration with a chat model.
@@ -28,6 +28,7 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
     topK: number;
     stopSequences: string[];
     safetySettings: GoogleAISafetySetting[];
+    safetyHandler: GoogleAISafetyHandler;
     protected connection: ChatConnection<AuthOptions>;
     protected streamedConnection: ChatConnection<AuthOptions>;
     constructor(fields?: ChatGoogleBaseInput<AuthOptions>);

package/dist/chat_models.js

@@ -4,8 +4,9 @@ import { ChatGenerationChunk } from "@langchain/core/outputs";
 import { AIMessageChunk } from "@langchain/core/messages";
 import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
-import { baseMessageToContent, responseToChatGeneration, responseToChatResult, } from "./utils/gemini.js";
+import { baseMessageToContent, safeResponseToChatGeneration, safeResponseToChatResult, DefaultGeminiSafetyHandler, } from "./utils/gemini.js";
 import { ApiKeyGoogleAuth } from "./auth.js";
+import { ensureParams } from "./utils/failed_handler.js";
 class ChatConnection extends AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         return input
@@ -22,7 +23,7 @@ export class ChatGoogleBase extends BaseChatModel {
         return "ChatGoogle";
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(ensureParams(fields));
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -71,6 +72,12 @@ export class ChatGoogleBase extends BaseChatModel {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "safetyHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -84,6 +91,8 @@ export class ChatGoogleBase extends BaseChatModel {
             value: void 0
         });
         copyAndValidateModelParamsInto(fields, this);
+        this.safetyHandler =
+            fields?.safetyHandler ?? new DefaultGeminiSafetyHandler();
         const client = this.buildClient(fields);
         this.buildConnection(fields ?? {}, client);
     }
@@ -116,7 +125,7 @@ export class ChatGoogleBase extends BaseChatModel {
     async _generate(messages, options, _runManager) {
         const parameters = copyAIModelParams(this);
         const response = await this.connection.request(messages, parameters, options);
-        const ret = responseToChatResult(response);
+        const ret = safeResponseToChatResult(response, this.safetyHandler);
         return ret;
     }
     async *_streamResponseChunks(_messages, _options, _runManager) {
@@ -131,7 +140,7 @@ export class ChatGoogleBase extends BaseChatModel {
         while (!stream.streamDone) {
             const output = await stream.nextChunk();
             const chunk = output !== null
-                ? responseToChatGeneration({ data: output })
+                ? safeResponseToChatGeneration({ data: output }, this.safetyHandler)
                 : new ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },

package/dist/llms.cjs

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GoogleBaseLLM = void 0;
+const manager_1 = require("@langchain/core/callbacks/manager");
 const llms_1 = require("@langchain/core/language_models/llms");
 const outputs_1 = require("@langchain/core/outputs");
 const env_1 = require("@langchain/core/utils/env");
@@ -8,6 +9,8 @@ const connection_js_1 = require("./connection.cjs");
 const common_js_1 = require("./utils/common.cjs");
 const gemini_js_1 = require("./utils/gemini.cjs");
 const auth_js_1 = require("./auth.cjs");
+const failed_handler_js_1 = require("./utils/failed_handler.cjs");
+const chat_models_js_1 = require("./chat_models.cjs");
 class GoogleLLMConnection extends connection_js_1.AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         const parts = (0, gemini_js_1.messageContentToParts)(input);
@@ -20,6 +23,14 @@ class GoogleLLMConnection extends connection_js_1.AbstractGoogleLLMConnection {
         return contents;
     }
 }
+class ProxyChatGoogle extends chat_models_js_1.ChatGoogleBase {
+    constructor(fields) {
+        super(fields);
+    }
+    buildAbstractedClient(fields) {
+        return fields.connection.client;
+    }
+}
 /**
  * Integration with an LLM.
  */
@@ -29,7 +40,13 @@ class GoogleBaseLLM extends llms_1.LLM {
         return "GoogleLLM";
     }
     constructor(fields) {
-        super(fields ?? {});
+        super((0, failed_handler_js_1.ensureParams)(fields));
+        Object.defineProperty(this, "originalFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -78,6 +95,12 @@ class GoogleBaseLLM extends llms_1.LLM {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "safetyHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -90,7 +113,10 @@ class GoogleBaseLLM extends llms_1.LLM {
             writable: true,
             value: void 0
         });
+        this.originalFields = fields;
         (0, common_js_1.copyAndValidateModelParamsInto)(fields, this);
+        this.safetyHandler =
+            fields?.safetyHandler ?? new gemini_js_1.DefaultGeminiSafetyHandler();
         const client = this.buildClient(fields);
         this.buildConnection(fields ?? {}, client);
     }
@@ -125,38 +151,79 @@ class GoogleBaseLLM extends llms_1.LLM {
     }
     /**
      * For some given input string and options, return a string output.
+     *
+     * Despite the fact that `invoke` is overridden below, we still need this
+     * in order to handle public APi calls to `generate()`.
      */
-    async _call(_prompt, _options, _runManager) {
+    async _call(prompt, options) {
         const parameters = (0, common_js_1.copyAIModelParams)(this);
-        const result = await this.connection.request(_prompt, parameters, _options);
-        const ret = (0, gemini_js_1.responseToString)(result);
+        const result = await this.connection.request(prompt, parameters, options);
+        const ret = (0, gemini_js_1.safeResponseToString)(result, this.safetyHandler);
         return ret;
     }
-    async *_streamResponseChunks(_prompt, _options, _runManager) {
-        // Make the call as a streaming request
-        const parameters = (0, common_js_1.copyAIModelParams)(this);
-        const result = await this.streamedConnection.request(_prompt, parameters, _options);
-        // Get the streaming parser of the response
-        const stream = result.data;
-        // Loop until the end of the stream
-        // During the loop, yield each time we get a chunk from the streaming parser
-        // that is either available or added to the queue
-        while (!stream.streamDone) {
-            const output = await stream.nextChunk();
-            const chunk = output !== null
-                ? new outputs_1.GenerationChunk((0, gemini_js_1.responseToGeneration)({ data: output }))
-                : new outputs_1.GenerationChunk({
-                    text: "",
-                    generationInfo: { finishReason: "stop" },
+    // Normally, you should not override this method and instead should override
+    // _streamResponseChunks. We are doing so here to allow for multimodal inputs into
+    // the LLM.
+    async *_streamIterator(input, options) {
+        // TODO: Refactor callback setup and teardown code into core
+        const prompt = llms_1.BaseLLM._convertInputToPromptValue(input);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+        const callbackManager_ = await manager_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+        const extra = {
+            options: callOptions,
+            invocation_params: this?.invocationParams(callOptions),
+            batch_size: 1,
+        };
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+        let generation = new outputs_1.GenerationChunk({
+            text: "",
+        });
+        const proxyChat = this.createProxyChat();
+        try {
+            for await (const chunk of proxyChat._streamIterator(input, options)) {
+                const stringValue = (0, gemini_js_1.chunkToString)(chunk);
+                const generationChunk = new outputs_1.GenerationChunk({
+                    text: stringValue,
                 });
-            yield chunk;
+                generation = generation.concat(generationChunk);
+                yield stringValue;
+            }
+        }
+        catch (err) {
+            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+            throw err;
         }
+        await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
+            generations: [[generation]],
+        })));
     }
     async predictMessages(messages, options, _callbacks) {
         const { content } = messages[0];
         const result = await this.connection.request(content, {}, options);
-        const ret = (0, gemini_js_1.responseToBaseMessage)(result);
+        const ret = (0, gemini_js_1.safeResponseToBaseMessage)(result, this.safetyHandler);
         return ret;
     }
+    /**
+     * Internal implementation detail to allow Google LLMs to support
+     * multimodal input by delegating to the chat model implementation.
+     *
+     * TODO: Replace with something less hacky.
+     */
+    createProxyChat() {
+        return new ProxyChatGoogle({
+            ...this.originalFields,
+            connection: this.connection,
+        });
+    }
+    // TODO: Remove the need to override this - we are doing it to
+    // allow the LLM to handle multimodal types of input.
+    async invoke(input, options) {
+        const stream = await this._streamIterator(input, options);
+        let generatedOutput = "";
+        for await (const chunk of stream) {
+            generatedOutput += chunk;
+        }
+        return generatedOutput;
+    }
 }
 exports.GoogleBaseLLM = GoogleBaseLLM;

package/dist/llms.d.ts

@@ -1,24 +1,22 @@
-import { CallbackManagerForLLMRun, Callbacks } from "@langchain/core/callbacks/manager";
+import { Callbacks } from "@langchain/core/callbacks/manager";
 import { LLM } from "@langchain/core/language_models/llms";
-import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
+import { type BaseLanguageModelCallOptions, BaseLanguageModelInput } from "@langchain/core/language_models/base";
 import { BaseMessage, MessageContent } from "@langchain/core/messages";
-import { GenerationChunk } from "@langchain/core/outputs";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GooglePlatformType, GeminiContent } from "./types.js";
 import { GoogleAbstractedClient } from "./auth.js";
+import { ChatGoogleBase } from "./chat_models.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler } from "./types.js";
+export { GoogleBaseLLMInput };
 declare class GoogleLLMConnection<AuthOptions> extends AbstractGoogleLLMConnection<MessageContent, AuthOptions> {
     formatContents(input: MessageContent, _parameters: GoogleAIModelParams): GeminiContent[];
 }
-/**
- * Input to LLM class.
- */
-export interface GoogleBaseLLMInput<AuthOptions> extends GoogleAIBaseLLMInput<AuthOptions> {
-}
 /**
  * Integration with an LLM.
  */
 export declare abstract class GoogleBaseLLM<AuthOptions> extends LLM<BaseLanguageModelCallOptions> implements GoogleBaseLLMInput<AuthOptions> {
     static lc_name(): string;
+    originalFields?: GoogleBaseLLMInput<AuthOptions>;
     lc_serializable: boolean;
     model: string;
     temperature: number;
@@ -27,6 +25,7 @@ export declare abstract class GoogleBaseLLM<AuthOptions> extends LLM<BaseLanguag
     topK: number;
     stopSequences: string[];
     safetySettings: GoogleAISafetySetting[];
+    safetyHandler: GoogleAISafetyHandler;
     protected connection: GoogleLLMConnection<AuthOptions>;
     protected streamedConnection: GoogleLLMConnection<AuthOptions>;
     constructor(fields?: GoogleBaseLLMInput<AuthOptions>);
@@ -40,9 +39,19 @@ export declare abstract class GoogleBaseLLM<AuthOptions> extends LLM<BaseLanguag
     formatPrompt(prompt: string): MessageContent;
     /**
      * For some given input string and options, return a string output.
+     *
+     * Despite the fact that `invoke` is overridden below, we still need this
+     * in order to handle public APi calls to `generate()`.
      */
-    _call(_prompt: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): Promise<string>;
-    _streamResponseChunks(_prompt: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
+    _call(prompt: string, options: this["ParsedCallOptions"]): Promise<string>;
+    _streamIterator(input: BaseLanguageModelInput, options?: BaseLanguageModelCallOptions): AsyncGenerator<string>;
     predictMessages(messages: BaseMessage[], options?: string[] | BaseLanguageModelCallOptions, _callbacks?: Callbacks): Promise<BaseMessage>;
+    /**
+     * Internal implementation detail to allow Google LLMs to support
+     * multimodal input by delegating to the chat model implementation.
+     *
+     * TODO: Replace with something less hacky.
+     */
+    protected createProxyChat(): ChatGoogleBase<AuthOptions>;
+    invoke(input: BaseLanguageModelInput, options?: BaseLanguageModelCallOptions): Promise<string>;
 }
-export {};

package/dist/llms.js

@@ -1,10 +1,13 @@
-import { LLM } from "@langchain/core/language_models/llms";
+import { CallbackManager } from "@langchain/core/callbacks/manager";
+import { BaseLLM, LLM } from "@langchain/core/language_models/llms";
 import { GenerationChunk } from "@langchain/core/outputs";
 import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
-import { messageContentToParts, responseToBaseMessage, responseToGeneration, responseToString, } from "./utils/gemini.js";
+import { chunkToString, messageContentToParts, safeResponseToBaseMessage, safeResponseToString, DefaultGeminiSafetyHandler, } from "./utils/gemini.js";
 import { ApiKeyGoogleAuth } from "./auth.js";
+import { ensureParams } from "./utils/failed_handler.js";
+import { ChatGoogleBase } from "./chat_models.js";
 class GoogleLLMConnection extends AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         const parts = messageContentToParts(input);
@@ -17,6 +20,14 @@ class GoogleLLMConnection extends AbstractGoogleLLMConnection {
         return contents;
     }
 }
+class ProxyChatGoogle extends ChatGoogleBase {
+    constructor(fields) {
+        super(fields);
+    }
+    buildAbstractedClient(fields) {
+        return fields.connection.client;
+    }
+}
 /**
  * Integration with an LLM.
  */
@@ -26,7 +37,13 @@ export class GoogleBaseLLM extends LLM {
         return "GoogleLLM";
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(ensureParams(fields));
+        Object.defineProperty(this, "originalFields", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
@@ -75,6 +92,12 @@ export class GoogleBaseLLM extends LLM {
             writable: true,
             value: []
         });
+        Object.defineProperty(this, "safetyHandler", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "connection", {
             enumerable: true,
             configurable: true,
@@ -87,7 +110,10 @@ export class GoogleBaseLLM extends LLM {
             writable: true,
             value: void 0
         });
+        this.originalFields = fields;
         copyAndValidateModelParamsInto(fields, this);
+        this.safetyHandler =
+            fields?.safetyHandler ?? new DefaultGeminiSafetyHandler();
         const client = this.buildClient(fields);
         this.buildConnection(fields ?? {}, client);
     }
@@ -122,37 +148,78 @@ export class GoogleBaseLLM extends LLM {
     }
     /**
      * For some given input string and options, return a string output.
+     *
+     * Despite the fact that `invoke` is overridden below, we still need this
+     * in order to handle public APi calls to `generate()`.
      */
-    async _call(_prompt, _options, _runManager) {
+    async _call(prompt, options) {
         const parameters = copyAIModelParams(this);
-        const result = await this.connection.request(_prompt, parameters, _options);
-        const ret = responseToString(result);
+        const result = await this.connection.request(prompt, parameters, options);
+        const ret = safeResponseToString(result, this.safetyHandler);
         return ret;
     }
-    async *_streamResponseChunks(_prompt, _options, _runManager) {
-        // Make the call as a streaming request
-        const parameters = copyAIModelParams(this);
-        const result = await this.streamedConnection.request(_prompt, parameters, _options);
-        // Get the streaming parser of the response
-        const stream = result.data;
-        // Loop until the end of the stream
-        // During the loop, yield each time we get a chunk from the streaming parser
-        // that is either available or added to the queue
-        while (!stream.streamDone) {
-            const output = await stream.nextChunk();
-            const chunk = output !== null
-                ? new GenerationChunk(responseToGeneration({ data: output }))
-                : new GenerationChunk({
-                    text: "",
-                    generationInfo: { finishReason: "stop" },
+    // Normally, you should not override this method and instead should override
+    // _streamResponseChunks. We are doing so here to allow for multimodal inputs into
+    // the LLM.
+    async *_streamIterator(input, options) {
+        // TODO: Refactor callback setup and teardown code into core
+        const prompt = BaseLLM._convertInputToPromptValue(input);
+        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
+        const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+        const extra = {
+            options: callOptions,
+            invocation_params: this?.invocationParams(callOptions),
+            batch_size: 1,
+        };
+        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
+        let generation = new GenerationChunk({
+            text: "",
+        });
+        const proxyChat = this.createProxyChat();
+        try {
+            for await (const chunk of proxyChat._streamIterator(input, options)) {
+                const stringValue = chunkToString(chunk);
+                const generationChunk = new GenerationChunk({
+                    text: stringValue,
                 });
-            yield chunk;
+                generation = generation.concat(generationChunk);
+                yield stringValue;
+            }
+        }
+        catch (err) {
+            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
+            throw err;
         }
+        await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
+            generations: [[generation]],
+        })));
     }
     async predictMessages(messages, options, _callbacks) {
         const { content } = messages[0];
         const result = await this.connection.request(content, {}, options);
-        const ret = responseToBaseMessage(result);
+        const ret = safeResponseToBaseMessage(result, this.safetyHandler);
         return ret;
     }
+    /**
+     * Internal implementation detail to allow Google LLMs to support
+     * multimodal input by delegating to the chat model implementation.
+     *
+     * TODO: Replace with something less hacky.
+     */
+    createProxyChat() {
+        return new ProxyChatGoogle({
+            ...this.originalFields,
+            connection: this.connection,
+        });
+    }
+    // TODO: Remove the need to override this - we are doing it to
+    // allow the LLM to handle multimodal types of input.
+    async invoke(input, options) {
+        const stream = await this._streamIterator(input, options);
+        let generatedOutput = "";
+        for await (const chunk of stream) {
+            generatedOutput += chunk;
+        }
+        return generatedOutput;
+    }
 }

package/dist/types.d.ts

@@ -67,7 +67,12 @@ export interface GoogleAIModelParams {
     stopSequences?: string[];
     safetySettings?: GoogleAISafetySetting[];
 }
-export interface GoogleAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams {
+export interface GoogleAIBaseLLMInput<AuthOptions> extends BaseLLMParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams {
+}
+/**
+ * Input to LLM class.
+ */
+export interface GoogleBaseLLMInput<AuthOptions> extends GoogleAIBaseLLMInput<AuthOptions> {
 }
 export interface GoogleResponse {
     data: any;
@@ -76,20 +81,28 @@ export interface GeminiPartText {
     text: string;
 }
 export interface GeminiPartInlineData {
-    mimeType: string;
-    data: string;
+    inlineData: {
+        mimeType: string;
+        data: string;
+    };
 }
 export interface GeminiPartFileData {
-    mimeType: string;
-    fileUri: string;
+    fileData: {
+        mimeType: string;
+        fileUri: string;
+    };
 }
 export interface GeminiPartFunctionCall {
-    name: string;
-    args?: object;
+    functionCall: {
+        name: string;
+        args?: object;
+    };
 }
 export interface GeminiPartFunctionResponse {
-    name: string;
-    response: object;
+    functionResponse: {
+        name: string;
+        response: object;
+    };
 }
 export type GeminiPart = GeminiPartText | GeminiPartInlineData | GeminiPartFileData | GeminiPartFunctionCall | GeminiPartFunctionResponse;
 export interface GeminiSafetySetting {
@@ -132,6 +145,7 @@ interface GeminiResponseCandidate {
     safetyRatings: GeminiSafetyRating[];
 }
 interface GeminiResponsePromptFeedback {
+    blockReason?: string;
     safetyRatings: GeminiSafetyRating[];
 }
 export interface GenerateContentResponseData {
@@ -143,4 +157,16 @@ export type GoogleLLMResponseData = JsonStream | GenerateContentResponseData | G
 export interface GoogleLLMResponse extends GoogleResponse {
     data: GoogleLLMResponseData;
 }
+export interface GoogleAISafetyHandler {
+    /**
+     * A function that will take a response and return the, possibly modified,
+     * response or throw an exception if there are safety issues.
+     *
+     * @throws GoogleAISafetyError
+     */
+    handle(response: GoogleLLMResponse): GoogleLLMResponse;
+}
+export interface GoogleAISafetyParams {
+    safetyHandler?: GoogleAISafetyHandler;
+}
 export {};

package/dist/utils/failed_handler.cjs

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureParams = exports.failedAttemptHandler = void 0;
+const STATUS_NO_RETRY = [
+    400,
+    401,
+    402,
+    403,
+    404,
+    405,
+    406,
+    407,
+    408,
+    409, // Conflict
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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;
+}
+exports.failedAttemptHandler = failedAttemptHandler;
+function ensureParams(params) {
+    const base = params ?? {};
+    return {
+        onFailedAttempt: failedAttemptHandler,
+        ...base,
+    };
+}
+exports.ensureParams = ensureParams;

package/dist/utils/failed_handler.d.ts

@@ -0,0 +1,3 @@
+import { AsyncCallerParams } from "@langchain/core/utils/async_caller";
+export declare function failedAttemptHandler(error: any): void;
+export declare function ensureParams(params?: AsyncCallerParams): AsyncCallerParams;