@langchain/google-common 0.0.27 → 0.1.0

package/dist/auth.cjs

@@ -3,6 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ensureAuthOptionScopes = exports.aiPlatformScope = exports.ApiKeyGoogleAuth = exports.GoogleAbstractedFetchClient = void 0;
 const stream_js_1 = require("./utils/stream.cjs");
 class GoogleAbstractedFetchClient {
+    async _buildData(res, opts) {
+        switch (opts.responseType) {
+            case "json":
+                return res.json();
+            case "stream":
+                return new stream_js_1.ReadableJsonStream(res.body);
+            default:
+                return res.blob();
+        }
+    }
     async _request(url, opts, additionalHeaders) {
         if (url == null)
             throw new Error("Missing URL");
@@ -15,20 +25,31 @@ class GoogleAbstractedFetchClient {
             },
         };
         if (opts.data !== undefined) {
-            fetchOptions.body = JSON.stringify(opts.data);
+            if (typeof opts.data === "string") {
+                fetchOptions.body = opts.data;
+            }
+            else {
+                fetchOptions.body = JSON.stringify(opts.data);
+            }
         }
         const res = await fetch(url, fetchOptions);
         if (!res.ok) {
             const resText = await res.text();
             const error = new Error(`Google request failed with status code ${res.status}: ${resText}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            /* eslint-disable @typescript-eslint/no-explicit-any */
             error.response = res;
+            error.details = {
+                url,
+                opts,
+                fetchOptions,
+                result: res,
+            };
+            /* eslint-enable @typescript-eslint/no-explicit-any */
             throw error;
         }
+        const data = await this._buildData(res, opts);
         return {
-            data: opts.responseType === "json"
-                ? await res.json()
-                : new stream_js_1.ReadableJsonStream(res.body),
+            data,
             config: {},
             status: res.status,
             statusText: res.statusText,

package/dist/auth.d.ts

@@ -1,6 +1,6 @@
 import { GooglePlatformType } from "./types.js";
-export type GoogleAbstractedClientOpsMethod = "GET" | "POST";
-export type GoogleAbstractedClientOpsResponseType = "json" | "stream";
+export type GoogleAbstractedClientOpsMethod = "GET" | "POST" | "DELETE";
+export type GoogleAbstractedClientOpsResponseType = "json" | "stream" | "blob";
 export type GoogleAbstractedClientOps = {
     url?: string;
     method?: GoogleAbstractedClientOpsMethod;
@@ -17,6 +17,7 @@ export declare abstract class GoogleAbstractedFetchClient implements GoogleAbstr
     abstract get clientType(): string;
     abstract getProjectId(): Promise<string>;
     abstract request(opts: GoogleAbstractedClientOps): unknown;
+    _buildData(res: Response, opts: GoogleAbstractedClientOps): Promise<any>;
     _request(url: string | undefined, opts: GoogleAbstractedClientOps, additionalHeaders: Record<string, string>): Promise<{
         data: any;
         config: {};

package/dist/auth.js

@@ -1,5 +1,15 @@
 import { ReadableJsonStream } from "./utils/stream.js";
 export class GoogleAbstractedFetchClient {
+    async _buildData(res, opts) {
+        switch (opts.responseType) {
+            case "json":
+                return res.json();
+            case "stream":
+                return new ReadableJsonStream(res.body);
+            default:
+                return res.blob();
+        }
+    }
     async _request(url, opts, additionalHeaders) {
         if (url == null)
             throw new Error("Missing URL");
@@ -12,20 +22,31 @@ export class GoogleAbstractedFetchClient {
             },
         };
         if (opts.data !== undefined) {
-            fetchOptions.body = JSON.stringify(opts.data);
+            if (typeof opts.data === "string") {
+                fetchOptions.body = opts.data;
+            }
+            else {
+                fetchOptions.body = JSON.stringify(opts.data);
+            }
         }
         const res = await fetch(url, fetchOptions);
         if (!res.ok) {
             const resText = await res.text();
             const error = new Error(`Google request failed with status code ${res.status}: ${resText}`);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            /* eslint-disable @typescript-eslint/no-explicit-any */
             error.response = res;
+            error.details = {
+                url,
+                opts,
+                fetchOptions,
+                result: res,
+            };
+            /* eslint-enable @typescript-eslint/no-explicit-any */
             throw error;
         }
+        const data = await this._buildData(res, opts);
         return {
-            data: opts.responseType === "json"
-                ? await res.json()
-                : new ReadableJsonStream(res.body),
+            data,
             config: {},
             status: res.status,
             statusText: res.statusText,

package/dist/chat_models.cjs

@@ -53,10 +53,10 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
         }
         return true;
     }
-    formatContents(input, _parameters) {
-        return input
-            .map((msg, i) => (0, gemini_js_1.baseMessageToContent)(msg, input[i - 1], this.useSystemInstruction))
-            .reduce((acc, cur) => {
+    async formatContents(input, _parameters) {
+        const inputPromises = input.map((msg, i) => this.api.baseMessageToContent(msg, input[i - 1], this.useSystemInstruction));
+        const inputs = await Promise.all(inputPromises);
+        return inputs.reduce((acc, cur) => {
             // Filter out the system content
             if (cur.every((content) => content.role === "system")) {
                 return acc;
@@ -76,24 +76,25 @@ class ChatConnection extends connection_js_1.AbstractGoogleLLMConnection {
             return acc;
         }, []);
     }
-    formatSystemInstruction(input, _parameters) {
+    async formatSystemInstruction(input, _parameters) {
         if (!this.useSystemInstruction) {
             return {};
         }
         let ret = {};
-        input.forEach((message, index) => {
+        for (let index = 0; index < input.length; index += 1) {
+            const message = input[index];
             if (message._getType() === "system") {
                 // For system types, we only want it if it is the first message,
                 // if it appears anywhere else, it should be an error.
                 if (index === 0) {
                     // eslint-disable-next-line prefer-destructuring
-                    ret = (0, gemini_js_1.baseMessageToContent)(message, undefined, true)[0];
+                    ret = (await this.api.baseMessageToContent(message, undefined, true))[0];
                 }
                 else {
                     throw new Error("System messages are only permitted as the first passed message.");
                 }
             }
-        });
+        }
         return ret;
     }
 }
@@ -273,7 +274,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
             };
         }
         const response = await this.connection.request(messages, parameters, options);
-        const ret = (0, gemini_js_1.safeResponseToChatResult)(response, this.safetyHandler);
+        const ret = this.connection.api.safeResponseToChatResult(response, this.safetyHandler);
         await runManager?.handleLLMNewToken(ret.generations[0].text);
         return ret;
     }
@@ -300,7 +301,7 @@ class ChatGoogleBase extends chat_models_1.BaseChatModel {
                 };
             }
             const chunk = output !== null
-                ? (0, gemini_js_1.safeResponseToChatGeneration)({ data: output }, this.safetyHandler)
+                ? this.connection.api.safeResponseToChatGeneration({ data: output }, this.safetyHandler)
                 : new outputs_1.ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },

package/dist/chat_models.d.ts

@@ -10,19 +10,19 @@ import { AsyncCaller } from "@langchain/core/utils/async_caller";
 import { GoogleAIBaseLLMInput, GoogleAIModelParams, GoogleAISafetySetting, GoogleConnectionParams, GooglePlatformType, GeminiContent, GoogleAIBaseLanguageModelCallOptions } from "./types.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
 import { GoogleAbstractedClient } from "./auth.js";
-import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType } from "./types.js";
+import type { GoogleBaseLLMInput, GoogleAISafetyHandler, GoogleAISafetyParams, GoogleAIToolType, GeminiAPIConfig } from "./types.js";
 declare class ChatConnection<AuthOptions> extends AbstractGoogleLLMConnection<BaseMessage[], AuthOptions> {
     convertSystemMessageToHumanContent: boolean | undefined;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming: boolean);
     get useSystemInstruction(): boolean;
     get computeUseSystemInstruction(): boolean;
-    formatContents(input: BaseMessage[], _parameters: GoogleAIModelParams): GeminiContent[];
-    formatSystemInstruction(input: BaseMessage[], _parameters: GoogleAIModelParams): GeminiContent;
+    formatContents(input: BaseMessage[], _parameters: GoogleAIModelParams): Promise<GeminiContent[]>;
+    formatSystemInstruction(input: BaseMessage[], _parameters: GoogleAIModelParams): Promise<GeminiContent>;
 }
 /**
  * Input to chat model class.
  */
-export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams, Pick<GoogleAIBaseLanguageModelCallOptions, "streamUsage"> {
+export interface ChatGoogleBaseInput<AuthOptions> extends BaseChatModelParams, GoogleConnectionParams<AuthOptions>, GoogleAIModelParams, GoogleAISafetyParams, GeminiAPIConfig, Pick<GoogleAIBaseLanguageModelCallOptions, "streamUsage"> {
 }
 /**
  * Integration with a Google chat model.

package/dist/chat_models.js

@@ -7,7 +7,7 @@ import { JsonOutputKeyToolsParser } from "@langchain/core/output_parsers/openai_
 import { concat } from "@langchain/core/utils/stream";
 import { convertToGeminiTools, copyAIModelParams, copyAndValidateModelParamsInto, } from "./utils/common.js";
 import { AbstractGoogleLLMConnection } from "./connection.js";
-import { baseMessageToContent, safeResponseToChatGeneration, safeResponseToChatResult, DefaultGeminiSafetyHandler, } from "./utils/gemini.js";
+import { 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";
@@ -50,10 +50,10 @@ class ChatConnection extends AbstractGoogleLLMConnection {
         }
         return true;
     }
-    formatContents(input, _parameters) {
-        return input
-            .map((msg, i) => baseMessageToContent(msg, input[i - 1], this.useSystemInstruction))
-            .reduce((acc, cur) => {
+    async formatContents(input, _parameters) {
+        const inputPromises = input.map((msg, i) => this.api.baseMessageToContent(msg, input[i - 1], this.useSystemInstruction));
+        const inputs = await Promise.all(inputPromises);
+        return inputs.reduce((acc, cur) => {
             // Filter out the system content
             if (cur.every((content) => content.role === "system")) {
                 return acc;
@@ -73,24 +73,25 @@ class ChatConnection extends AbstractGoogleLLMConnection {
             return acc;
         }, []);
     }
-    formatSystemInstruction(input, _parameters) {
+    async formatSystemInstruction(input, _parameters) {
         if (!this.useSystemInstruction) {
             return {};
         }
         let ret = {};
-        input.forEach((message, index) => {
+        for (let index = 0; index < input.length; index += 1) {
+            const message = input[index];
             if (message._getType() === "system") {
                 // For system types, we only want it if it is the first message,
                 // if it appears anywhere else, it should be an error.
                 if (index === 0) {
                     // eslint-disable-next-line prefer-destructuring
-                    ret = baseMessageToContent(message, undefined, true)[0];
+                    ret = (await this.api.baseMessageToContent(message, undefined, true))[0];
                 }
                 else {
                     throw new Error("System messages are only permitted as the first passed message.");
                 }
             }
-        });
+        }
         return ret;
     }
 }
@@ -270,7 +271,7 @@ export class ChatGoogleBase extends BaseChatModel {
             };
         }
         const response = await this.connection.request(messages, parameters, options);
-        const ret = safeResponseToChatResult(response, this.safetyHandler);
+        const ret = this.connection.api.safeResponseToChatResult(response, this.safetyHandler);
         await runManager?.handleLLMNewToken(ret.generations[0].text);
         return ret;
     }
@@ -297,7 +298,7 @@ export class ChatGoogleBase extends BaseChatModel {
                 };
             }
             const chunk = output !== null
-                ? safeResponseToChatGeneration({ data: output }, this.safetyHandler)
+                ? this.connection.api.safeResponseToChatGeneration({ data: output }, this.safetyHandler)
                 : new ChatGenerationChunk({
                     text: "",
                     generationInfo: { finishReason: "stop" },

package/dist/connection.cjs

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
+exports.AbstractGoogleLLMConnection = exports.GoogleAIConnection = exports.GoogleRawConnection = exports.GoogleHostConnection = exports.GoogleConnection = void 0;
 const env_1 = require("@langchain/core/utils/env");
 const function_calling_1 = require("@langchain/core/utils/function_calling");
 const zod_to_gemini_parameters_js_1 = require("./utils/zod_to_gemini_parameters.cjs");
+const index_js_1 = require("./utils/index.cjs");
 class GoogleConnection {
     constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
@@ -53,12 +54,18 @@ class GoogleConnection {
     async _moduleName() {
         return this.constructor.name;
     }
-    async _request(data, options) {
+    async additionalHeaders() {
+        return {};
+    }
+    async _buildOpts(data, _options, requestHeaders = {}) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
         const infoHeaders = (await this._clientInfoHeaders()) ?? {};
+        const additionalHeaders = (await this.additionalHeaders()) ?? {};
         const headers = {
             ...infoHeaders,
+            ...additionalHeaders,
+            ...requestHeaders,
         };
         const opts = {
             url,
@@ -74,6 +81,10 @@ class GoogleConnection {
         else {
             opts.responseType = "json";
         }
+        return opts;
+    }
+    async _request(data, options, requestHeaders = {}) {
+        const opts = await this._buildOpts(data, options, requestHeaders);
         const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
         const response = callResponse; // Done for typecast safety, I guess
         return response;
@@ -127,6 +138,14 @@ class GoogleHostConnection extends GoogleConnection {
     }
 }
 exports.GoogleHostConnection = GoogleHostConnection;
+class GoogleRawConnection extends GoogleHostConnection {
+    async _buildOpts(data, _options, requestHeaders = {}) {
+        const opts = await super._buildOpts(data, _options, requestHeaders);
+        opts.responseType = "blob";
+        return opts;
+    }
+}
+exports.GoogleRawConnection = GoogleRawConnection;
 class GoogleAIConnection extends GoogleHostConnection {
     constructor(fields, caller, client, streaming) {
         super(fields, caller, client, streaming);
@@ -148,9 +167,17 @@ class GoogleAIConnection extends GoogleHostConnection {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // FIXME: Make this a real type
         this.client = client;
         this.modelName = fields?.model ?? fields?.modelName ?? this.model;
         this.model = this.modelName;
+        this.api = (0, index_js_1.getGeminiAPI)(fields);
     }
     get modelFamily() {
         if (this.model.startsWith("gemini")) {
@@ -188,7 +215,7 @@ class GoogleAIConnection extends GoogleHostConnection {
         }
     }
     async request(input, parameters, options) {
-        const data = this.formatData(input, parameters);
+        const data = await this.formatData(input, parameters);
         const response = await this._request(data, options);
         return response;
     }
@@ -219,7 +246,7 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
     formatSafetySettings(_input, parameters) {
         return parameters.safetySettings ?? [];
     }
-    formatSystemInstruction(_input, _parameters) {
+    async formatSystemInstruction(_input, _parameters) {
         return {};
     }
     structuredToolToFunctionDeclaration(tool) {
@@ -265,13 +292,13 @@ class AbstractGoogleLLMConnection extends GoogleAIConnection {
             },
         };
     }
-    formatData(input, parameters) {
-        const contents = this.formatContents(input, parameters);
+    async formatData(input, parameters) {
+        const contents = await this.formatContents(input, parameters);
         const generationConfig = this.formatGenerationConfig(input, parameters);
         const tools = this.formatTools(input, parameters);
         const toolConfig = this.formatToolConfig(parameters);
         const safetySettings = this.formatSafetySettings(input, parameters);
-        const systemInstruction = this.formatSystemInstruction(input, parameters);
+        const systemInstruction = await this.formatSystemInstruction(input, parameters);
         const ret = {
             contents,
             generationConfig,

package/dist/connection.d.ts

@@ -1,8 +1,8 @@
 import { BaseLanguageModelCallOptions } from "@langchain/core/language_models/base";
 import { AsyncCaller, AsyncCallerCallOptions } from "@langchain/core/utils/async_caller";
 import { StructuredToolParams } 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";
+import type { GoogleAIBaseLLMInput, GoogleConnectionParams, GoogleLLMModelFamily, GooglePlatformType, GoogleResponse, GoogleLLMResponse, GeminiContent, GeminiGenerationConfig, GeminiRequest, GeminiSafetySetting, GeminiTool, GeminiFunctionDeclaration, GoogleAIModelRequestParams, GoogleRawResponse } from "./types.js";
+import { GoogleAbstractedClient, GoogleAbstractedClientOps, GoogleAbstractedClientOpsMethod } from "./auth.js";
 export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse> {
     caller: AsyncCaller;
     client: GoogleAbstractedClient;
@@ -16,7 +16,9 @@ export declare abstract class GoogleConnection<CallOptions extends AsyncCallerCa
         clientLibraryVersion: string;
     }>;
     _moduleName(): Promise<string>;
-    _request(data: unknown | undefined, options: CallOptions): Promise<ResponseType>;
+    additionalHeaders(): Promise<Record<string, string>>;
+    _buildOpts(data: unknown | undefined, _options: CallOptions, requestHeaders?: Record<string, string>): Promise<GoogleAbstractedClientOps>;
+    _request(data: unknown | undefined, options: CallOptions, requestHeaders?: Record<string, string>): Promise<ResponseType>;
 }
 export declare abstract class GoogleHostConnection<CallOptions extends AsyncCallerCallOptions, ResponseType extends GoogleResponse, AuthOptions> extends GoogleConnection<CallOptions, ResponseType> implements GoogleConnectionParams<AuthOptions> {
     platformType: GooglePlatformType | undefined;
@@ -28,10 +30,14 @@ export declare abstract class GoogleHostConnection<CallOptions extends AsyncCall
     get computedPlatformType(): GooglePlatformType;
     buildMethod(): GoogleAbstractedClientOpsMethod;
 }
+export declare abstract class GoogleRawConnection<CallOptions extends AsyncCallerCallOptions, AuthOptions> extends GoogleHostConnection<CallOptions, GoogleRawResponse, AuthOptions> {
+    _buildOpts(data: unknown | undefined, _options: CallOptions, requestHeaders?: Record<string, string>): Promise<GoogleAbstractedClientOps>;
+}
 export declare abstract class GoogleAIConnection<CallOptions extends AsyncCallerCallOptions, InputType, AuthOptions, ResponseType extends GoogleResponse> extends GoogleHostConnection<CallOptions, ResponseType, AuthOptions> implements GoogleAIBaseLLMInput<AuthOptions> {
     model: string;
     modelName: string;
     client: GoogleAbstractedClient;
+    api: any;
     constructor(fields: GoogleAIBaseLLMInput<AuthOptions> | undefined, caller: AsyncCaller, client: GoogleAbstractedClient, streaming?: boolean);
     get modelFamily(): GoogleLLMModelFamily;
     get computedPlatformType(): GooglePlatformType;
@@ -39,19 +45,19 @@ export declare abstract class GoogleAIConnection<CallOptions extends AsyncCaller
     buildUrlGenerativeLanguage(): Promise<string>;
     buildUrlVertex(): Promise<string>;
     buildUrl(): Promise<string>;
-    abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): unknown;
-    request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<ResponseType>;
+    abstract formatData(input: InputType, parameters: GoogleAIModelRequestParams): Promise<unknown>;
+    request(input: InputType, parameters: GoogleAIModelRequestParams, options: CallOptions): Promise<GoogleResponse>;
 }
 export declare abstract class AbstractGoogleLLMConnection<MessageType, AuthOptions> extends GoogleAIConnection<BaseLanguageModelCallOptions, MessageType, AuthOptions, GoogleLLMResponse> {
     buildUrlMethodGemini(): Promise<string>;
     buildUrlMethod(): Promise<string>;
-    abstract formatContents(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiContent[];
+    abstract formatContents(input: MessageType, parameters: GoogleAIModelRequestParams): Promise<GeminiContent[]>;
     formatGenerationConfig(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiGenerationConfig;
     formatSafetySettings(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiSafetySetting[];
-    formatSystemInstruction(_input: MessageType, _parameters: GoogleAIModelRequestParams): GeminiContent;
+    formatSystemInstruction(_input: MessageType, _parameters: GoogleAIModelRequestParams): Promise<GeminiContent>;
     structuredToolToFunctionDeclaration(tool: StructuredToolParams): GeminiFunctionDeclaration;
     structuredToolsToGeminiTools(tools: StructuredToolParams[]): GeminiTool[];
     formatTools(_input: MessageType, parameters: GoogleAIModelRequestParams): GeminiTool[];
     formatToolConfig(parameters: GoogleAIModelRequestParams): GeminiRequest["toolConfig"] | undefined;
-    formatData(input: MessageType, parameters: GoogleAIModelRequestParams): GeminiRequest;
+    formatData(input: MessageType, parameters: GoogleAIModelRequestParams): Promise<GeminiRequest>;
 }

package/dist/connection.js

@@ -1,6 +1,7 @@
 import { getRuntimeEnvironment } from "@langchain/core/utils/env";
 import { isLangChainTool } from "@langchain/core/utils/function_calling";
 import { zodToGeminiParameters } from "./utils/zod_to_gemini_parameters.js";
+import { getGeminiAPI } from "./utils/index.js";
 export class GoogleConnection {
     constructor(caller, client, streaming) {
         Object.defineProperty(this, "caller", {
@@ -50,12 +51,18 @@ export class GoogleConnection {
     async _moduleName() {
         return this.constructor.name;
     }
-    async _request(data, options) {
+    async additionalHeaders() {
+        return {};
+    }
+    async _buildOpts(data, _options, requestHeaders = {}) {
         const url = await this.buildUrl();
         const method = this.buildMethod();
         const infoHeaders = (await this._clientInfoHeaders()) ?? {};
+        const additionalHeaders = (await this.additionalHeaders()) ?? {};
         const headers = {
             ...infoHeaders,
+            ...additionalHeaders,
+            ...requestHeaders,
         };
         const opts = {
             url,
@@ -71,6 +78,10 @@ export class GoogleConnection {
         else {
             opts.responseType = "json";
         }
+        return opts;
+    }
+    async _request(data, options, requestHeaders = {}) {
+        const opts = await this._buildOpts(data, options, requestHeaders);
         const callResponse = await this.caller.callWithOptions({ signal: options?.signal }, async () => this.client.request(opts));
         const response = callResponse; // Done for typecast safety, I guess
         return response;
@@ -122,6 +133,13 @@ export class GoogleHostConnection extends GoogleConnection {
         return "POST";
     }
 }
+export class GoogleRawConnection extends GoogleHostConnection {
+    async _buildOpts(data, _options, requestHeaders = {}) {
+        const opts = await super._buildOpts(data, _options, requestHeaders);
+        opts.responseType = "blob";
+        return opts;
+    }
+}
 export class GoogleAIConnection extends GoogleHostConnection {
     constructor(fields, caller, client, streaming) {
         super(fields, caller, client, streaming);
@@ -143,9 +161,17 @@ export class GoogleAIConnection extends GoogleHostConnection {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        Object.defineProperty(this, "api", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        }); // FIXME: Make this a real type
         this.client = client;
         this.modelName = fields?.model ?? fields?.modelName ?? this.model;
         this.model = this.modelName;
+        this.api = getGeminiAPI(fields);
     }
     get modelFamily() {
         if (this.model.startsWith("gemini")) {
@@ -183,7 +209,7 @@ export class GoogleAIConnection extends GoogleHostConnection {
         }
     }
     async request(input, parameters, options) {
-        const data = this.formatData(input, parameters);
+        const data = await this.formatData(input, parameters);
         const response = await this._request(data, options);
         return response;
     }
@@ -213,7 +239,7 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
     formatSafetySettings(_input, parameters) {
         return parameters.safetySettings ?? [];
     }
-    formatSystemInstruction(_input, _parameters) {
+    async formatSystemInstruction(_input, _parameters) {
         return {};
     }
     structuredToolToFunctionDeclaration(tool) {
@@ -259,13 +285,13 @@ export class AbstractGoogleLLMConnection extends GoogleAIConnection {
             },
         };
     }
-    formatData(input, parameters) {
-        const contents = this.formatContents(input, parameters);
+    async formatData(input, parameters) {
+        const contents = await this.formatContents(input, parameters);
         const generationConfig = this.formatGenerationConfig(input, parameters);
         const tools = this.formatTools(input, parameters);
         const toolConfig = this.formatToolConfig(parameters);
         const safetySettings = this.formatSafetySettings(input, parameters);
-        const systemInstruction = this.formatSystemInstruction(input, parameters);
+        const systemInstruction = await this.formatSystemInstruction(input, parameters);
         const ret = {
             contents,
             generationConfig,

package/dist/embeddings.cjs

@@ -19,7 +19,7 @@ class EmbeddingsConnection extends connection_js_1.GoogleAIConnection {
     async buildUrlMethod() {
         return "predict";
     }
-    formatData(input, parameters) {
+    async formatData(input, parameters) {
         return {
             instances: input,
             parameters,
@@ -79,7 +79,9 @@ class BaseGoogleEmbeddings extends embeddings_1.Embeddings {
         const options = {};
         const responses = await Promise.all(instanceChunks.map((instances) => this.connection.request(instances, parameters, options)));
         const result = responses
-            ?.map((response) => response?.data?.predictions?.map((result) => result.embeddings.values) ?? [])
+            ?.map((response) => response?.data?.predictions?.map(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (result) => result.embeddings?.values) ?? [])
             .flat() ?? [];
         return result;
     }

package/dist/embeddings.js

@@ -16,7 +16,7 @@ class EmbeddingsConnection extends GoogleAIConnection {
     async buildUrlMethod() {
         return "predict";
     }
-    formatData(input, parameters) {
+    async formatData(input, parameters) {
         return {
             instances: input,
             parameters,
@@ -76,7 +76,9 @@ export class BaseGoogleEmbeddings extends Embeddings {
         const options = {};
         const responses = await Promise.all(instanceChunks.map((instances) => this.connection.request(instances, parameters, options)));
         const result = responses
-            ?.map((response) => response?.data?.predictions?.map((result) => result.embeddings.values) ?? [])
+            ?.map((response) => response?.data?.predictions?.map(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (result) => result.embeddings?.values) ?? [])
             .flat() ?? [];
         return result;
     }