@langchain/google-common 0.0.0 → 0.0.2

package/README.md

@@ -27,14 +27,14 @@ file storage.
 ## Google services supported
 
 * Gemini model through LLM and Chat classes (both through Google AI Studio and 
-  Google Cloud Vertex AI)
+  Google Cloud Vertex AI). Including:
+  * Function/Tool support 
 
 
 ## TODO
 
 Tasks and services still to be implemented:
 
-* Functions for Gemini
 * PaLM Vertex AI support and backwards compatibility
 * PaLM MakerSuite support and backwards compatibility
 * Semantic Retrieval / AQA model
@@ -43,5 +43,10 @@ Tasks and services still to be implemented:
 * Multimodal embeddings
 * Vertex AI Search
 * Vertex AI Model Garden
+  * Online prediction endpoints
+    * Gemma
+  * Google managed models
+    * Claude
+* AI Studio Tuned Models
 * MakerSuite / Google Drive Hub
 * Google Cloud Vector Store

package/dist/chat_models.cjs

@@ -5,10 +5,14 @@ const env_1 = require("@langchain/core/utils/env");
 const chat_models_1 = require("@langchain/core/language_models/chat_models");
 const outputs_1 = require("@langchain/core/outputs");
 const messages_1 = require("@langchain/core/messages");
+const runnables_1 = require("@langchain/core/runnables");
+const openai_tools_1 = require("@langchain/core/output_parsers/openai_tools");
 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");
+const zod_to_gemini_parameters_js_1 = require("./utils/zod_to_gemini_parameters.cjs");
 class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         return input
@@ -25,19 +29,26 @@ 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,
             writable: true,
             value: true
         });
+        /** @deprecated Prefer `modelName` */
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "gemini-pro"
         });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
         Object.defineProperty(this, "temperature", {
             enumerable: true,
             configurable: true,
@@ -74,6 +85,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 +104,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);
     }
@@ -117,15 +136,15 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
         return "chat_integration";
     }
     async _generate(messages, options, _runManager) {
-        const parameters = (0, common_js_1.copyAIModelParams)(this);
+        const parameters = (0, common_js_1.copyAIModelParams)(this, options);
         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) {
+    async *_streamResponseChunks(_messages, options, _runManager) {
         // Make the call as a streaming request
-        const parameters = (0, common_js_1.copyAIModelParams)(this);
-        const response = await this.streamedConnection.request(_messages, parameters, _options);
+        const parameters = (0, common_js_1.copyAIModelParams)(this, options);
+        const response = await this.streamedConnection.request(_messages, parameters, options);
         // Get the streaming parser of the response
         const stream = response.data;
         // Loop until the end of the stream
@@ -134,7 +153,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" },
@@ -149,5 +168,94 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
     _combineLLMOutput() {
         return [];
     }
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schema = outputSchema;
+        const name = config?.name;
+        const method = config?.method;
+        const includeRaw = config?.includeRaw;
+        if (method === "jsonMode") {
+            throw new Error(`Google only supports "functionCalling" as a method.`);
+        }
+        let functionName = name ?? "extract";
+        let outputParser;
+        let tools;
+        if (isZodSchema(schema)) {
+            const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(schema);
+            tools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: functionName,
+                            description: jsonSchema.description ?? "A function available to call.",
+                            parameters: jsonSchema,
+                        },
+                    ],
+                },
+            ];
+            outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
+        }
+        else {
+            let geminiFunctionDefinition;
+            if (typeof schema.name === "string" &&
+                typeof schema.parameters === "object" &&
+                schema.parameters != null) {
+                geminiFunctionDefinition = schema;
+                functionName = schema.name;
+            }
+            else {
+                geminiFunctionDefinition = {
+                    name: functionName,
+                    description: schema.description ?? "",
+                    parameters: schema,
+                };
+            }
+            tools = [
+                {
+                    functionDeclarations: [geminiFunctionDefinition],
+                },
+            ];
+            outputParser = new openai_tools_1.JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatGoogleStructuredOutput",
+            });
+        }
+        const parserAssign = runnables_1.RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = runnables_1.RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return runnables_1.RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
 }
 exports.ChatGoogleBase = ChatGoogleBase;
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
+}

package/dist/chat_models.d.ts

@@ -1,33 +1,38 @@
 import { type BaseMessage } from "@langchain/core/messages";
-import { type BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { ChatGenerationChunk, ChatResult } from "@langchain/core/outputs";
-import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent } from "./types.js";
+import { BaseLanguageModelInput, StructuredOutputMethodOptions } from "@langchain/core/language_models/base";
+import type { z } from "zod";
+import { Runnable } from "@langchain/core/runnables";
+import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent, GoogleAIBaseLanguageModelCallOptions } 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.
  */
-export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<BaseLanguageModelCallOptions> implements ChatGoogleBaseInput<AuthOptions> {
+export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<GoogleAIBaseLanguageModelCallOptions> implements ChatGoogleBaseInput<AuthOptions> {
     static lc_name(): string;
     lc_serializable: boolean;
+    /** @deprecated Prefer `modelName` */
     model: string;
+    modelName: string;
     temperature: number;
     maxOutputTokens: number;
     topP: number;
     topK: number;
     stopSequences: string[];
     safetySettings: GoogleAISafetySetting[];
+    safetyHandler: GoogleAISafetyHandler;
     protected connection: ChatConnection<AuthOptions>;
     protected streamedConnection: ChatConnection<AuthOptions>;
     constructor(fields?: ChatGoogleBaseInput<AuthOptions>);
@@ -39,8 +44,13 @@ export declare abstract class ChatGoogleBase<AuthOptions> extends BaseChatModel<
     get platform(): GooglePlatformType;
     _llmType(): string;
     _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager: CallbackManagerForLLMRun | undefined): Promise<ChatResult>;
-    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
+    _streamResponseChunks(_messages: BaseMessage[], options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     /** @ignore */
     _combineLLMOutput(): never[];
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<false>): Runnable<BaseLanguageModelInput, RunOutput>;
+    withStructuredOutput<RunOutput extends Record<string, any> = Record<string, any>>(outputSchema: z.ZodType<RunOutput> | Record<string, any>, config?: StructuredOutputMethodOptions<true>): Runnable<BaseLanguageModelInput, {
+        raw: BaseMessage;
+        parsed: RunOutput;
+    }>;
 }
 export {};

package/dist/chat_models.js

@@ -2,10 +2,14 @@ import { getEnvironmentVariable } from "@langchain/core/utils/env";
 import { BaseChatModel, } from "@langchain/core/language_models/chat_models";
 import { ChatGenerationChunk } from "@langchain/core/outputs";
 import { AIMessageChunk } from "@langchain/core/messages";
+import { RunnablePassthrough, RunnableSequence, } from "@langchain/core/runnables";
+import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_tools";
 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";
+import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
 class ChatConnection extends AbstractGoogleLLMConnection {
     formatContents(input, _parameters) {
         return input
@@ -22,19 +26,26 @@ export class ChatGoogleBase extends BaseChatModel {
         return "ChatGoogle";
     }
     constructor(fields) {
-        super(fields ?? {});
+        super(ensureParams(fields));
         Object.defineProperty(this, "lc_serializable", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: true
         });
+        /** @deprecated Prefer `modelName` */
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: "gemini-pro"
         });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "gemini-pro"
+        });
         Object.defineProperty(this, "temperature", {
             enumerable: true,
             configurable: true,
@@ -71,6 +82,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 +101,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);
     }
@@ -114,15 +133,15 @@ export class ChatGoogleBase extends BaseChatModel {
         return "chat_integration";
     }
     async _generate(messages, options, _runManager) {
-        const parameters = copyAIModelParams(this);
+        const parameters = copyAIModelParams(this, options);
         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) {
+    async *_streamResponseChunks(_messages, options, _runManager) {
         // Make the call as a streaming request
-        const parameters = copyAIModelParams(this);
-        const response = await this.streamedConnection.request(_messages, parameters, _options);
+        const parameters = copyAIModelParams(this, options);
+        const response = await this.streamedConnection.request(_messages, parameters, options);
         // Get the streaming parser of the response
         const stream = response.data;
         // Loop until the end of the stream
@@ -131,7 +150,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" },
@@ -146,4 +165,93 @@ export class ChatGoogleBase extends BaseChatModel {
     _combineLLMOutput() {
         return [];
     }
+    withStructuredOutput(outputSchema, config) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const schema = outputSchema;
+        const name = config?.name;
+        const method = config?.method;
+        const includeRaw = config?.includeRaw;
+        if (method === "jsonMode") {
+            throw new Error(`Google only supports "functionCalling" as a method.`);
+        }
+        let functionName = name ?? "extract";
+        let outputParser;
+        let tools;
+        if (isZodSchema(schema)) {
+            const jsonSchema = zodToGeminiParameters(schema);
+            tools = [
+                {
+                    functionDeclarations: [
+                        {
+                            name: functionName,
+                            description: jsonSchema.description ?? "A function available to call.",
+                            parameters: jsonSchema,
+                        },
+                    ],
+                },
+            ];
+            outputParser = new JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+                zodSchema: schema,
+            });
+        }
+        else {
+            let geminiFunctionDefinition;
+            if (typeof schema.name === "string" &&
+                typeof schema.parameters === "object" &&
+                schema.parameters != null) {
+                geminiFunctionDefinition = schema;
+                functionName = schema.name;
+            }
+            else {
+                geminiFunctionDefinition = {
+                    name: functionName,
+                    description: schema.description ?? "",
+                    parameters: schema,
+                };
+            }
+            tools = [
+                {
+                    functionDeclarations: [geminiFunctionDefinition],
+                },
+            ];
+            outputParser = new JsonOutputKeyToolsParser({
+                returnSingle: true,
+                keyName: functionName,
+            });
+        }
+        const llm = this.bind({
+            tools,
+        });
+        if (!includeRaw) {
+            return llm.pipe(outputParser).withConfig({
+                runName: "ChatGoogleStructuredOutput",
+            });
+        }
+        const parserAssign = RunnablePassthrough.assign({
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            parsed: (input, config) => outputParser.invoke(input.raw, config),
+        });
+        const parserNone = RunnablePassthrough.assign({
+            parsed: () => null,
+        });
+        const parsedWithFallback = parserAssign.withFallbacks({
+            fallbacks: [parserNone],
+        });
+        return RunnableSequence.from([
+            {
+                raw: llm,
+            },
+            parsedWithFallback,
+        ]).withConfig({
+            runName: "StructuredOutputRunnable",
+        });
+    }
+}
+function isZodSchema(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input) {
+    // Check for a characteristic method of Zod schemas
+    return typeof input?.parse === "function";
 }

package/dist/connection.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
 const env_1 = require("@langchain/core/utils/env");
+const zod_to_gemini_parameters_js_1 = require("./utils/zod_to_gemini_parameters.cjs");
 class GoogleConnection {
     constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
@@ -123,12 +124,19 @@ exports.GoogleHostConnection = GoogleHostConnection;
 class GoogleAIConnection extends GoogleHostConnection {
     constructor(fields, caller, client, streaming) {
         super(fields, caller, client, streaming);
+        /** @deprecated Prefer `modelName` */
         Object.defineProperty(this, "model", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "client", {
             enumerable: true,
             configurable: true,
@@ -136,10 +144,10 @@ class GoogleAIConnection extends GoogleHostConnection {
             value: void 0
         });
         this.client = client;
-        this.model = fields?.model ?? this.model;
+        this.modelName = fields?.modelName ?? fields?.model ?? this.modelName;
     }
     get modelFamily() {
-        if (this.model.startsWith("gemini")) {
+        if (this.modelName.startsWith("gemini")) {
             return "gemini";
         }
         else {
@@ -156,13 +164,13 @@ class GoogleAIConnection extends GoogleHostConnection {
     }
     async buildUrlGenerativeLanguage() {
         const method = await this.buildUrlMethod();
-        const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.model}:${method}`;
+        const url = `https://generativelanguage.googleapis.com/${this.apiVersion}/models/${this.modelName}:${method}`;
         return url;
     }
     async buildUrlVertex() {
         const projectId = await this.client.getProjectId();
         const method = await this.buildUrlMethod();
-        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.model}:${method}`;
+        const url = `https://${this.endpoint}/${this.apiVersion}/projects/${projectId}/locations/${this.location}/publishers/google/models/${this.modelName}:${method}`;
         return url;
     }
     async buildUrl() {
@@ -205,6 +213,38 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
     formatSafetySettings(_input, parameters) {
         return parameters.safetySettings ?? [];
     }
+    // Borrowed from the OpenAI invocation params test
+    isStructuredToolArray(tools) {
+        return (tools !== undefined &&
+            tools.every((tool) => Array.isArray(tool.lc_namespace)));
+    }
+    structuredToolToFunctionDeclaration(tool) {
+        const jsonSchema = (0, zod_to_gemini_parameters_js_1.zodToGeminiParameters)(tool.schema);
+        return {
+            name: tool.name,
+            description: tool.description,
+            parameters: jsonSchema,
+        };
+    }
+    structuredToolsToGeminiTools(tools) {
+        return [
+            {
+                functionDeclarations: tools.map(this.structuredToolToFunctionDeclaration),
+            },
+        ];
+    }
+    formatTools(_input, parameters) {
+        const tools = parameters?.tools;
+        if (!tools || tools.length === 0) {
+            return [];
+        }
+        if (this.isStructuredToolArray(tools)) {
+            return this.structuredToolsToGeminiTools(tools);
+        }
+        else {
+            return tools;
+        }
+    }
     formatData(input, parameters) {
         /*
         const parts = messageContentToParts(input);
@@ -217,11 +257,15 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
         */
         const contents = this.formatContents(input, parameters);
         const generationConfig = this.formatGenerationConfig(input, parameters);
+        const tools = this.formatTools(input, parameters);
         const safetySettings = this.formatSafetySettings(input, parameters);
         const ret = {
             contents,
             generationConfig,
         };
+        if (tools && tools.length) {
+            ret.tools = tools;
+        }
         if (safetySettings && safetySettings.length) {
             ret.safetySettings = safetySettings;
         }

package/dist/connection.d.ts

@@ -1,6 +1,7 @@
 import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
 import { AsyncCaller, AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
-import type { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleConnectionParams, GoogleLLMModelFamily, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GeminiContent, GeminiGenerationConfig, GeminiRequest, GeminiSafetySetting } from "./types.js";
+import { StructuredToolInterface } from "@langchain/core/tools";
+import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GoogleLLMModelFamily, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GeminiContent, GeminiGenerationConfig, GeminiRequest, GeminiSafetySetting, GeminiTool, GeminiFunctionDeclaration, GoogleAIModelRequestParams } from "./types.js";
 import { GoogleAbstractedClient, GoogleAbstractedClientOpsMethod } from "./auth.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
     caller: AsyncCaller;
@@ -25,7 +26,9 @@ export declare abstract class GoogleHostConnection<CallOptions extends AsyncCall
     buildMethod(): GoogleAbstractedClientOpsMethod;
 }
 export declare abstract class GoogleAIConnection<CallOptions extends BaseLanguageModelCallOptions, MessageType, AuthOptions> extends GoogleHostConnection<CallOptions, GoogleLLMResponse, AuthOptions> implements GoogleAIBaseLLMInput<AuthOptions> {
+    /** @deprecated Prefer `modelName` */
     model: string;
+    modelName: string;
     client: GoogleAbstractedClient;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     get modelFamily(): GoogleLLMModelFamily;
@@ -34,14 +37,18 @@ export declare abstract class GoogleAIConnection<CallOptions extends BaseLanguag
     buildUrlGenerativeLanguage(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
-    abstract formatData(input: MessageType, parameters: GoogleAIModelParams): unknown;
-    request(input: MessageType, parameters: GoogleAIModelParams, options: CallOptions): Promise<GoogleLLMResponse>;
+    abstract formatData(input: MessageType, parameters: GoogleAIModelRequestParams): unknown;
+    request(input: MessageType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<GoogleLLMResponse>;
 }
 export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions> {
     buildUrlMethodGemini(): Promise<string>;
     buildUrlMethod(): Promise<string>;
-    abstract formatContents(input: MessageType, parameters: GoogleAIModelParams): GeminiContent[];
-    formatGenerationConfig(_input: MessageType, parameters: GoogleAIModelParams): GeminiGenerationConfig;
-    formatSafetySettings(_input: MessageType, parameters: GoogleAIModelParams): GeminiSafetySetting[];
-    formatData(input: MessageType, parameters: GoogleAIModelParams): GeminiRequest;
+    abstract formatContents(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiContent[];
+    formatGenerationConfig(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiGenerationConfig;
+    formatSafetySettings(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiSafetySetting[];
+    isStructuredToolArray(tools?: unknown[]): tools is StructuredToolInterface[];
+    structuredToolToFunctionDeclaration(tool: StructuredToolInterface): GeminiFunctionDeclaration;
+    structuredToolsToGeminiTools(tools: StructuredToolInterface[]): GeminiTool[];
+    formatTools(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiTool[];
+    formatData(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiRequest;
 }