@google/genai 1.32.0 → 1.34.0

package/dist/index.cjs

@@ -758,21 +758,29 @@ exports.PhishBlockThreshold = void 0;
      */
     PhishBlockThreshold["BLOCK_ONLY_EXTREMELY_HIGH"] = "BLOCK_ONLY_EXTREMELY_HIGH";
 })(exports.PhishBlockThreshold || (exports.PhishBlockThreshold = {}));
-/** The level of thoughts tokens that the model should generate. */
+/** The number of thoughts tokens that the model should generate. */
 exports.ThinkingLevel = void 0;
 (function (ThinkingLevel) {
     /**
-     * Default value.
+     * Unspecified thinking level.
      */
     ThinkingLevel["THINKING_LEVEL_UNSPECIFIED"] = "THINKING_LEVEL_UNSPECIFIED";
     /**
      * Low thinking level.
      */
     ThinkingLevel["LOW"] = "LOW";
+    /**
+     * Medium thinking level.
+     */
+    ThinkingLevel["MEDIUM"] = "MEDIUM";
     /**
      * High thinking level.
      */
     ThinkingLevel["HIGH"] = "HIGH";
+    /**
+     * MINIMAL thinking level.
+     */
+    ThinkingLevel["MINIMAL"] = "MINIMAL";
 })(exports.ThinkingLevel || (exports.ThinkingLevel = {}));
 /** Harm category. */
 exports.HarmCategory = void 0;
@@ -931,6 +939,14 @@ exports.FinishReason = void 0;
      * The model was expected to generate an image, but none was generated.
      */
     FinishReason["NO_IMAGE"] = "NO_IMAGE";
+    /**
+     * Image generation stopped because the generated image may be a recitation from a source.
+     */
+    FinishReason["IMAGE_RECITATION"] = "IMAGE_RECITATION";
+    /**
+     * Image generation stopped for a reason not otherwise specified.
+     */
+    FinishReason["IMAGE_OTHER"] = "IMAGE_OTHER";
 })(exports.FinishReason || (exports.FinishReason = {}));
 /** Output only. Harm probability levels in the content. */
 exports.HarmProbability = void 0;
@@ -1235,6 +1251,10 @@ exports.PartMediaResolutionLevel = void 0;
      * Media resolution set to high.
      */
     PartMediaResolutionLevel["MEDIA_RESOLUTION_HIGH"] = "MEDIA_RESOLUTION_HIGH";
+    /**
+     * Media resolution set to ultra high.
+     */
+    PartMediaResolutionLevel["MEDIA_RESOLUTION_ULTRA_HIGH"] = "MEDIA_RESOLUTION_ULTRA_HIGH";
 })(exports.PartMediaResolutionLevel || (exports.PartMediaResolutionLevel = {}));
 /** Options for feature selection preference. */
 exports.FeatureSelectionPreference = void 0;
@@ -1553,6 +1573,22 @@ exports.MediaModality = void 0;
      */
     MediaModality["DOCUMENT"] = "DOCUMENT";
 })(exports.MediaModality || (exports.MediaModality = {}));
+/** The type of the VAD signal. */
+exports.VadSignalType = void 0;
+(function (VadSignalType) {
+    /**
+     * The default is VAD_SIGNAL_TYPE_UNSPECIFIED.
+     */
+    VadSignalType["VAD_SIGNAL_TYPE_UNSPECIFIED"] = "VAD_SIGNAL_TYPE_UNSPECIFIED";
+    /**
+     * Start of sentence signal.
+     */
+    VadSignalType["VAD_SIGNAL_TYPE_SOS"] = "VAD_SIGNAL_TYPE_SOS";
+    /**
+     * End of sentence signal.
+     */
+    VadSignalType["VAD_SIGNAL_TYPE_EOS"] = "VAD_SIGNAL_TYPE_EOS";
+})(exports.VadSignalType || (exports.VadSignalType = {}));
 /** Start of speech sensitivity. */
 exports.StartSensitivity = void 0;
 (function (StartSensitivity) {
@@ -6223,6 +6259,18 @@ PERFORMANCE OF THIS SOFTWARE.
 /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
 function __values(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -6849,7 +6897,7 @@ const CONTENT_TYPE_HEADER = 'Content-Type';
 const SERVER_TIMEOUT_HEADER = 'X-Server-Timeout';
 const USER_AGENT_HEADER = 'User-Agent';
 const GOOGLE_API_CLIENT_HEADER = 'x-goog-api-client';
-const SDK_VERSION = '1.32.0'; // x-release-please-version
+const SDK_VERSION = '1.34.0'; // x-release-please-version
 const LIBRARY_LABEL = `google-genai-sdk/${SDK_VERSION}`;
 const VERTEX_AI_API_DEFAULT_VERSION = 'v1beta1';
 const GOOGLE_AI_API_DEFAULT_VERSION = 'v1beta';
@@ -6923,6 +6971,11 @@ class ApiClient {
     getLocation() {
         return this.clientOptions.location;
     }
+    async getAuthHeaders() {
+        const headers = new Headers();
+        await this.clientOptions.auth.addAuthHeaders(headers);
+        return headers;
+    }
     getApiVersion() {
         if (this.clientOptions.httpOptions &&
             this.clientOptions.httpOptions.apiVersion !== undefined) {
@@ -7581,7 +7634,7 @@ async function uploadBlobInternal(file, uploadUrl, apiClient) {
                 break;
             }
             retryCount++;
-            await sleep(currentDelayMs);
+            await sleep$1(currentDelayMs);
             currentDelayMs = currentDelayMs * DELAY_MULTIPLIER;
         }
         offset += chunkSize;
@@ -7602,7 +7655,7 @@ async function getBlobStat(file) {
     const fileStat = { size: file.size, type: file.type };
     return fileStat;
 }
-function sleep(ms) {
+function sleep$1(ms) {
     return new Promise((resolvePromise) => setTimeout(resolvePromise, ms));
 }
 
@@ -8272,218 +8325,2210 @@ class FileSearchStores extends BaseModule {
         return this.apiClient.uploadFileToFileSearchStore(params.fileSearchStoreName, params.file, params.config);
     }
     /**
-     * Creates a File Search Store.
-     *
-     * @param params - The parameters for creating a File Search Store.
-     * @return FileSearchStore.
+     * Creates a File Search Store.
+     *
+     * @param params - The parameters for creating a File Search Store.
+     * @return FileSearchStore.
+     */
+    async create(params) {
+        var _a, _b;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = createFileSearchStoreParametersToMldev(params);
+            path = formatMap('fileSearchStores', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((resp) => {
+                return resp;
+            });
+        }
+    }
+    /**
+     * Gets a File Search Store.
+     *
+     * @param params - The parameters for getting a File Search Store.
+     * @return FileSearchStore.
+     */
+    async get(params) {
+        var _a, _b;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = getFileSearchStoreParametersToMldev(params);
+            path = formatMap('{name}', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((resp) => {
+                return resp;
+            });
+        }
+    }
+    /**
+     * Deletes a File Search Store.
+     *
+     * @param params - The parameters for deleting a File Search Store.
+     */
+    async delete(params) {
+        var _a, _b;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = deleteFileSearchStoreParametersToMldev(params);
+            path = formatMap('{name}', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            await this.apiClient.request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'DELETE',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            });
+        }
+    }
+    async listInternal(params) {
+        var _a, _b;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = listFileSearchStoresParametersToMldev(params);
+            path = formatMap('fileSearchStores', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'GET',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = listFileSearchStoresResponseFromMldev(apiResponse);
+                const typedResp = new ListFileSearchStoresResponse();
+                Object.assign(typedResp, resp);
+                return typedResp;
+            });
+        }
+    }
+    async uploadToFileSearchStoreInternal(params) {
+        var _a, _b;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = uploadToFileSearchStoreParametersToMldev(params);
+            path = formatMap('upload/v1beta/{file_search_store_name}:uploadToFileSearchStore', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = uploadToFileSearchStoreResumableResponseFromMldev(apiResponse);
+                const typedResp = new UploadToFileSearchStoreResumableResponse();
+                Object.assign(typedResp, resp);
+                return typedResp;
+            });
+        }
+    }
+    /**
+     * Imports a File from File Service to a FileSearchStore.
+     *
+     * This is a long-running operation, see aip.dev/151
+     *
+     * @param params - The parameters for importing a file to a file search store.
+     * @return ImportFileOperation.
+     */
+    async importFile(params) {
+        var _a, _b;
+        let response;
+        let path = '';
+        let queryParams = {};
+        if (this.apiClient.isVertexAI()) {
+            throw new Error('This method is only supported by the Gemini Developer API.');
+        }
+        else {
+            const body = importFileParametersToMldev(params);
+            path = formatMap('{file_search_store_name}:importFile', body['_url']);
+            queryParams = body['_query'];
+            delete body['_url'];
+            delete body['_query'];
+            response = this.apiClient
+                .request({
+                path: path,
+                queryParams: queryParams,
+                body: JSON.stringify(body),
+                httpMethod: 'POST',
+                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
+                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
+            })
+                .then((httpResponse) => {
+                return httpResponse.json();
+            });
+            return response.then((apiResponse) => {
+                const resp = importFileOperationFromMldev(apiResponse);
+                const typedResp = new ImportFileOperation();
+                Object.assign(typedResp, resp);
+                return typedResp;
+            });
+        }
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * https://stackoverflow.com/a/2117523
+ */
+let uuid4Internal = function () {
+    const { crypto } = globalThis;
+    if (crypto === null || crypto === void 0 ? void 0 : crypto.randomUUID) {
+        uuid4Internal = crypto.randomUUID.bind(crypto);
+        return crypto.randomUUID();
+    }
+    const u8 = new Uint8Array(1);
+    const randomByte = crypto ? () => crypto.getRandomValues(u8)[0] : () => (Math.random() * 0xff) & 0xff;
+    return '10000000-1000-4000-8000-100000000000'.replace(/[018]/g, (c) => (+c ^ (randomByte() & (15 >> (+c / 4)))).toString(16));
+};
+const uuid4 = () => uuid4Internal();
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+function isAbortError(err) {
+    return (typeof err === 'object' &&
+        err !== null &&
+        // Spec-compliant fetch implementations
+        (('name' in err && err.name === 'AbortError') ||
+            // Expo fetch
+            ('message' in err && String(err.message).includes('FetchRequestCanceledException'))));
+}
+const castToError = (err) => {
+    if (err instanceof Error)
+        return err;
+    if (typeof err === 'object' && err !== null) {
+        try {
+            if (Object.prototype.toString.call(err) === '[object Error]') {
+                // @ts-ignore - not all envs have native support for cause yet
+                const error = new Error(err.message, err.cause ? { cause: err.cause } : {});
+                if (err.stack)
+                    error.stack = err.stack;
+                // @ts-ignore - not all envs have native support for cause yet
+                if (err.cause && !error.cause)
+                    error.cause = err.cause;
+                if (err.name)
+                    error.name = err.name;
+                return error;
+            }
+        }
+        catch (_a) { }
+        try {
+            return new Error(JSON.stringify(err));
+        }
+        catch (_b) { }
+    }
+    return new Error(err);
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+class GeminiNextGenAPIClientError extends Error {
+}
+class APIError extends GeminiNextGenAPIClientError {
+    constructor(status, error, message, headers) {
+        super(`${APIError.makeMessage(status, error, message)}`);
+        this.status = status;
+        this.headers = headers;
+        this.error = error;
+    }
+    static makeMessage(status, error, message) {
+        const msg = (error === null || error === void 0 ? void 0 : error.message) ?
+            typeof error.message === 'string' ?
+                error.message
+                : JSON.stringify(error.message)
+            : error ? JSON.stringify(error)
+                : message;
+        if (status && msg) {
+            return `${status} ${msg}`;
+        }
+        if (status) {
+            return `${status} status code (no body)`;
+        }
+        if (msg) {
+            return msg;
+        }
+        return '(no status code or body)';
+    }
+    static generate(status, errorResponse, message, headers) {
+        if (!status || !headers) {
+            return new APIConnectionError({ message, cause: castToError(errorResponse) });
+        }
+        const error = errorResponse;
+        if (status === 400) {
+            return new BadRequestError(status, error, message, headers);
+        }
+        if (status === 401) {
+            return new AuthenticationError(status, error, message, headers);
+        }
+        if (status === 403) {
+            return new PermissionDeniedError(status, error, message, headers);
+        }
+        if (status === 404) {
+            return new NotFoundError(status, error, message, headers);
+        }
+        if (status === 409) {
+            return new ConflictError(status, error, message, headers);
+        }
+        if (status === 422) {
+            return new UnprocessableEntityError(status, error, message, headers);
+        }
+        if (status === 429) {
+            return new RateLimitError(status, error, message, headers);
+        }
+        if (status >= 500) {
+            return new InternalServerError(status, error, message, headers);
+        }
+        return new APIError(status, error, message, headers);
+    }
+}
+class APIUserAbortError extends APIError {
+    constructor({ message } = {}) {
+        super(undefined, undefined, message || 'Request was aborted.', undefined);
+    }
+}
+class APIConnectionError extends APIError {
+    constructor({ message, cause }) {
+        super(undefined, undefined, message || 'Connection error.', undefined);
+        // in some environments the 'cause' property is already declared
+        // @ts-ignore
+        if (cause)
+            this.cause = cause;
+    }
+}
+class APIConnectionTimeoutError extends APIConnectionError {
+    constructor({ message } = {}) {
+        super({ message: message !== null && message !== void 0 ? message : 'Request timed out.' });
+    }
+}
+class BadRequestError extends APIError {
+}
+class AuthenticationError extends APIError {
+}
+class PermissionDeniedError extends APIError {
+}
+class NotFoundError extends APIError {
+}
+class ConflictError extends APIError {
+}
+class UnprocessableEntityError extends APIError {
+}
+class RateLimitError extends APIError {
+}
+class InternalServerError extends APIError {
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+// https://url.spec.whatwg.org/#url-scheme-string
+const startsWithSchemeRegexp = /^[a-z][a-z0-9+.-]*:/i;
+const isAbsoluteURL = (url) => {
+    return startsWithSchemeRegexp.test(url);
+};
+let isArrayInternal = (val) => ((isArrayInternal = Array.isArray), isArrayInternal(val));
+const isArray = isArrayInternal;
+let isReadonlyArrayInternal = isArray;
+const isReadonlyArray = isReadonlyArrayInternal;
+// https://stackoverflow.com/a/34491287
+function isEmptyObj(obj) {
+    if (!obj)
+        return true;
+    for (const _k in obj)
+        return false;
+    return true;
+}
+// https://eslint.org/docs/latest/rules/no-prototype-builtins
+function hasOwn(obj, key) {
+    return Object.prototype.hasOwnProperty.call(obj, key);
+}
+const validatePositiveInteger = (name, n) => {
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+        throw new GeminiNextGenAPIClientError(`${name} must be an integer`);
+    }
+    if (n < 0) {
+        throw new GeminiNextGenAPIClientError(`${name} must be a positive integer`);
+    }
+    return n;
+};
+const safeJSON = (text) => {
+    try {
+        return JSON.parse(text);
+    }
+    catch (err) {
+        return undefined;
+    }
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const VERSION = '0.0.1';
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Note this does not detect 'browser'; for that, use getBrowserInfo().
+ */
+function getDetectedPlatform() {
+    if (typeof Deno !== 'undefined' && Deno.build != null) {
+        return 'deno';
+    }
+    if (typeof EdgeRuntime !== 'undefined') {
+        return 'edge';
+    }
+    if (Object.prototype.toString.call(typeof globalThis.process !== 'undefined' ? globalThis.process : 0) === '[object process]') {
+        return 'node';
+    }
+    return 'unknown';
+}
+const getPlatformProperties = () => {
+    var _a, _b, _c, _d, _e;
+    const detectedPlatform = getDetectedPlatform();
+    if (detectedPlatform === 'deno') {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': normalizePlatform(Deno.build.os),
+            'X-Stainless-Arch': normalizeArch(Deno.build.arch),
+            'X-Stainless-Runtime': 'deno',
+            'X-Stainless-Runtime-Version': typeof Deno.version === 'string' ? Deno.version : (_b = (_a = Deno.version) === null || _a === void 0 ? void 0 : _a.deno) !== null && _b !== void 0 ? _b : 'unknown',
+        };
+    }
+    if (typeof EdgeRuntime !== 'undefined') {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': 'Unknown',
+            'X-Stainless-Arch': `other:${EdgeRuntime}`,
+            'X-Stainless-Runtime': 'edge',
+            'X-Stainless-Runtime-Version': globalThis.process.version,
+        };
+    }
+    // Check if Node.js
+    if (detectedPlatform === 'node') {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': normalizePlatform((_c = globalThis.process.platform) !== null && _c !== void 0 ? _c : 'unknown'),
+            'X-Stainless-Arch': normalizeArch((_d = globalThis.process.arch) !== null && _d !== void 0 ? _d : 'unknown'),
+            'X-Stainless-Runtime': 'node',
+            'X-Stainless-Runtime-Version': (_e = globalThis.process.version) !== null && _e !== void 0 ? _e : 'unknown',
+        };
+    }
+    const browserInfo = getBrowserInfo();
+    if (browserInfo) {
+        return {
+            'X-Stainless-Lang': 'js',
+            'X-Stainless-Package-Version': VERSION,
+            'X-Stainless-OS': 'Unknown',
+            'X-Stainless-Arch': 'unknown',
+            'X-Stainless-Runtime': `browser:${browserInfo.browser}`,
+            'X-Stainless-Runtime-Version': browserInfo.version,
+        };
+    }
+    // TODO add support for Cloudflare workers, etc.
+    return {
+        'X-Stainless-Lang': 'js',
+        'X-Stainless-Package-Version': VERSION,
+        'X-Stainless-OS': 'Unknown',
+        'X-Stainless-Arch': 'unknown',
+        'X-Stainless-Runtime': 'unknown',
+        'X-Stainless-Runtime-Version': 'unknown',
+    };
+};
+// Note: modified from https://github.com/JS-DevTools/host-environment/blob/b1ab79ecde37db5d6e163c050e54fe7d287d7c92/src/isomorphic.browser.ts
+function getBrowserInfo() {
+    if (typeof navigator === 'undefined' || !navigator) {
+        return null;
+    }
+    // NOTE: The order matters here!
+    const browserPatterns = [
+        { key: 'edge', pattern: /Edge(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'ie', pattern: /MSIE(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'ie', pattern: /Trident(?:.*rv\:(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'chrome', pattern: /Chrome(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'firefox', pattern: /Firefox(?:\W+(\d+)\.(\d+)(?:\.(\d+))?)?/ },
+        { key: 'safari', pattern: /(?:Version\W+(\d+)\.(\d+)(?:\.(\d+))?)?(?:\W+Mobile\S*)?\W+Safari/ },
+    ];
+    // Find the FIRST matching browser
+    for (const { key, pattern } of browserPatterns) {
+        const match = pattern.exec(navigator.userAgent);
+        if (match) {
+            const major = match[1] || 0;
+            const minor = match[2] || 0;
+            const patch = match[3] || 0;
+            return { browser: key, version: `${major}.${minor}.${patch}` };
+        }
+    }
+    return null;
+}
+const normalizeArch = (arch) => {
+    // Node docs:
+    // - https://nodejs.org/api/process.html#processarch
+    // Deno docs:
+    // - https://doc.deno.land/deno/stable/~/Deno.build
+    if (arch === 'x32')
+        return 'x32';
+    if (arch === 'x86_64' || arch === 'x64')
+        return 'x64';
+    if (arch === 'arm')
+        return 'arm';
+    if (arch === 'aarch64' || arch === 'arm64')
+        return 'arm64';
+    if (arch)
+        return `other:${arch}`;
+    return 'unknown';
+};
+const normalizePlatform = (platform) => {
+    // Node platforms:
+    // - https://nodejs.org/api/process.html#processplatform
+    // Deno platforms:
+    // - https://doc.deno.land/deno/stable/~/Deno.build
+    // - https://github.com/denoland/deno/issues/14799
+    platform = platform.toLowerCase();
+    // NOTE: this iOS check is untested and may not work
+    // Node does not work natively on IOS, there is a fork at
+    // https://github.com/nodejs-mobile/nodejs-mobile
+    // however it is unknown at the time of writing how to detect if it is running
+    if (platform.includes('ios'))
+        return 'iOS';
+    if (platform === 'android')
+        return 'Android';
+    if (platform === 'darwin')
+        return 'MacOS';
+    if (platform === 'win32')
+        return 'Windows';
+    if (platform === 'freebsd')
+        return 'FreeBSD';
+    if (platform === 'openbsd')
+        return 'OpenBSD';
+    if (platform === 'linux')
+        return 'Linux';
+    if (platform)
+        return `Other:${platform}`;
+    return 'Unknown';
+};
+let _platformHeaders;
+const getPlatformHeaders = () => {
+    return (_platformHeaders !== null && _platformHeaders !== void 0 ? _platformHeaders : (_platformHeaders = getPlatformProperties()));
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function getDefaultFetch() {
+    if (typeof fetch !== 'undefined') {
+        return fetch;
+    }
+    throw new Error('`fetch` is not defined as a global; Either pass `fetch` to the client, `new GeminiNextGenAPIClient({ fetch })` or polyfill the global, `globalThis.fetch = fetch`');
+}
+function makeReadableStream(...args) {
+    const ReadableStream = globalThis.ReadableStream;
+    if (typeof ReadableStream === 'undefined') {
+        // Note: All of the platforms / runtimes we officially support already define
+        // `ReadableStream` as a global, so this should only ever be hit on unsupported runtimes.
+        throw new Error('`ReadableStream` is not defined as a global; You will need to polyfill it, `globalThis.ReadableStream = ReadableStream`');
+    }
+    return new ReadableStream(...args);
+}
+function ReadableStreamFrom(iterable) {
+    let iter = Symbol.asyncIterator in iterable ? iterable[Symbol.asyncIterator]() : iterable[Symbol.iterator]();
+    return makeReadableStream({
+        start() { },
+        async pull(controller) {
+            const { done, value } = await iter.next();
+            if (done) {
+                controller.close();
+            }
+            else {
+                controller.enqueue(value);
+            }
+        },
+        async cancel() {
+            var _a;
+            await ((_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter));
+        },
+    });
+}
+/**
+ * Most browsers don't yet have async iterable support for ReadableStream,
+ * and Node has a very different way of reading bytes from its "ReadableStream".
+ *
+ * This polyfill was pulled from https://github.com/MattiasBuelens/web-streams-polyfill/pull/122#issuecomment-1627354490
+ */
+function ReadableStreamToAsyncIterable(stream) {
+    if (stream[Symbol.asyncIterator])
+        return stream;
+    const reader = stream.getReader();
+    return {
+        async next() {
+            try {
+                const result = await reader.read();
+                if (result === null || result === void 0 ? void 0 : result.done)
+                    reader.releaseLock(); // release lock when stream becomes closed
+                return result;
+            }
+            catch (e) {
+                reader.releaseLock(); // release lock when stream becomes errored
+                throw e;
+            }
+        },
+        async return() {
+            const cancelPromise = reader.cancel();
+            reader.releaseLock();
+            await cancelPromise;
+            return { done: true, value: undefined };
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+/**
+ * Cancels a ReadableStream we don't need to consume.
+ * See https://undici.nodejs.org/#/?id=garbage-collection
+ */
+async function CancelReadableStream(stream) {
+    var _a, _b;
+    if (stream === null || typeof stream !== 'object')
+        return;
+    if (stream[Symbol.asyncIterator]) {
+        await ((_b = (_a = stream[Symbol.asyncIterator]()).return) === null || _b === void 0 ? void 0 : _b.call(_a));
+        return;
+    }
+    const reader = stream.getReader();
+    const cancelPromise = reader.cancel();
+    reader.releaseLock();
+    await cancelPromise;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const FallbackEncoder = ({ headers, body }) => {
+    return {
+        bodyHeaders: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify(body),
+    };
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const checkFileSupport = () => {
+    var _a;
+    if (typeof File === 'undefined') {
+        const { process } = globalThis;
+        const isOldNode = typeof ((_a = process === null || process === void 0 ? void 0 : process.versions) === null || _a === void 0 ? void 0 : _a.node) === 'string' && parseInt(process.versions.node.split('.')) < 20;
+        throw new Error('`File` is not defined as a global, which is required for file uploads.' +
+            (isOldNode ?
+                " Update to Node 20 LTS or newer, or set `globalThis.File` to `import('node:buffer').File`."
+                : ''));
+    }
+};
+/**
+ * Construct a `File` instance. This is used to ensure a helpful error is thrown
+ * for environments that don't define a global `File` yet.
+ */
+function makeFile(fileBits, fileName, options) {
+    checkFileSupport();
+    return new File(fileBits, fileName !== null && fileName !== void 0 ? fileName : 'unknown_file', options);
+}
+function getName(value) {
+    return (((typeof value === 'object' &&
+        value !== null &&
+        (('name' in value && value.name && String(value.name)) ||
+            ('url' in value && value.url && String(value.url)) ||
+            ('filename' in value && value.filename && String(value.filename)) ||
+            ('path' in value && value.path && String(value.path)))) ||
+        '')
+        .split(/[\\/]/)
+        .pop() || undefined);
+}
+const isAsyncIterable = (value) => value != null && typeof value === 'object' && typeof value[Symbol.asyncIterator] === 'function';
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isBlobLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.size === 'number' &&
+    typeof value.type === 'string' &&
+    typeof value.text === 'function' &&
+    typeof value.slice === 'function' &&
+    typeof value.arrayBuffer === 'function';
+/**
+ * This check adds the arrayBuffer() method type because it is available and used at runtime
+ */
+const isFileLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.name === 'string' &&
+    typeof value.lastModified === 'number' &&
+    isBlobLike(value);
+const isResponseLike = (value) => value != null &&
+    typeof value === 'object' &&
+    typeof value.url === 'string' &&
+    typeof value.blob === 'function';
+/**
+ * Helper for creating a {@link File} to pass to an SDK upload method from a variety of different data formats
+ * @param value the raw content of the file. Can be an {@link Uploadable}, BlobLikePart, or AsyncIterable of BlobLikeParts
+ * @param {string=} name the name of the file. If omitted, toFile will try to determine a file name from bits if possible
+ * @param {Object=} options additional properties
+ * @param {string=} options.type the MIME type of the content
+ * @param {number=} options.lastModified the last modified timestamp
+ * @returns a {@link File} with the given properties
+ */
+async function toFile(value, name, options) {
+    checkFileSupport();
+    // If it's a promise, resolve it.
+    value = await value;
+    // If we've been given a `File` we don't need to do anything
+    if (isFileLike(value)) {
+        if (value instanceof File) {
+            return value;
+        }
+        return makeFile([await value.arrayBuffer()], value.name);
+    }
+    if (isResponseLike(value)) {
+        const blob = await value.blob();
+        name || (name = new URL(value.url).pathname.split(/[\\/]/).pop());
+        return makeFile(await getBytes(blob), name, options);
+    }
+    const parts = await getBytes(value);
+    name || (name = getName(value));
+    if (!(options === null || options === void 0 ? void 0 : options.type)) {
+        const type = parts.find((part) => typeof part === 'object' && 'type' in part && part.type);
+        if (typeof type === 'string') {
+            options = Object.assign(Object.assign({}, options), { type });
+        }
+    }
+    return makeFile(parts, name, options);
+}
+async function getBytes(value) {
+    var _a, e_1, _b, _c;
+    var _d;
+    let parts = [];
+    if (typeof value === 'string' ||
+        ArrayBuffer.isView(value) || // includes Uint8Array, Buffer, etc.
+        value instanceof ArrayBuffer) {
+        parts.push(value);
+    }
+    else if (isBlobLike(value)) {
+        parts.push(value instanceof Blob ? value : await value.arrayBuffer());
+    }
+    else if (isAsyncIterable(value) // includes Readable, ReadableStream, etc.
+    ) {
+        try {
+            for (var _e = true, value_1 = __asyncValues(value), value_1_1; value_1_1 = await value_1.next(), _a = value_1_1.done, !_a; _e = true) {
+                _c = value_1_1.value;
+                _e = false;
+                const chunk = _c;
+                parts.push(...(await getBytes(chunk))); // TODO, consider validating?
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_a && (_b = value_1.return)) await _b.call(value_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    }
+    else {
+        const constructor = (_d = value === null || value === void 0 ? void 0 : value.constructor) === null || _d === void 0 ? void 0 : _d.name;
+        throw new Error(`Unexpected data type: ${typeof value}${constructor ? `; constructor: ${constructor}` : ''}${propsForError(value)}`);
+    }
+    return parts;
+}
+function propsForError(value) {
+    if (typeof value !== 'object' || value === null)
+        return '';
+    const props = Object.getOwnPropertyNames(value);
+    return `; props: [${props.map((p) => `"${p}"`).join(', ')}]`;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class APIResource {
+    constructor(client) {
+        this._client = client;
+    }
+}
+/**
+ * The key path from the client. For example, a resource accessible as `client.resource.subresource` would
+ * have a property `static override readonly _key = Object.freeze(['resource', 'subresource'] as const);`.
+ */
+APIResource._key = [];
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Percent-encode everything that isn't safe to have in a path without encoding safe chars.
+ *
+ * Taken from https://datatracker.ietf.org/doc/html/rfc3986#section-3.3:
+ * > unreserved  = ALPHA / DIGIT / "-" / "." / "_" / "~"
+ * > sub-delims  = "!" / "$" / "&" / "'" / "(" / ")" / "*" / "+" / "," / ";" / "="
+ * > pchar       = unreserved / pct-encoded / sub-delims / ":" / "@"
+ */
+function encodeURIPath(str) {
+    return str.replace(/[^A-Za-z0-9\-._~!$&'()*+,;=:@]+/g, encodeURIComponent);
+}
+const EMPTY = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.create(null));
+const createPathTagFunction = (pathEncoder = encodeURIPath) => (function path(statics, ...params) {
+    // If there are no params, no processing is needed.
+    if (statics.length === 1)
+        return statics[0];
+    let postPath = false;
+    const invalidSegments = [];
+    const path = statics.reduce((previousValue, currentValue, index) => {
+        var _a, _b, _c;
+        if (/[?#]/.test(currentValue)) {
+            postPath = true;
+        }
+        const value = params[index];
+        let encoded = (postPath ? encodeURIComponent : pathEncoder)('' + value);
+        if (index !== params.length &&
+            (value == null ||
+                (typeof value === 'object' &&
+                    // handle values from other realms
+                    value.toString ===
+                        ((_c = Object.getPrototypeOf((_b = Object.getPrototypeOf((_a = value.hasOwnProperty) !== null && _a !== void 0 ? _a : EMPTY)) !== null && _b !== void 0 ? _b : EMPTY)) === null || _c === void 0 ? void 0 : _c.toString)))) {
+            encoded = value + '';
+            invalidSegments.push({
+                start: previousValue.length + currentValue.length,
+                length: encoded.length,
+                error: `Value of type ${Object.prototype.toString
+                    .call(value)
+                    .slice(8, -1)} is not a valid path parameter`,
+            });
+        }
+        return previousValue + currentValue + (index === params.length ? '' : encoded);
+    }, '');
+    const pathOnly = path.split(/[?#]/, 1)[0];
+    const invalidSegmentPattern = /(?<=^|\/)(?:\.|%2e){1,2}(?=\/|$)/gi;
+    let match;
+    // Find all invalid segments
+    while ((match = invalidSegmentPattern.exec(pathOnly)) !== null) {
+        invalidSegments.push({
+            start: match.index,
+            length: match[0].length,
+            error: `Value "${match[0]}" can\'t be safely passed as a path parameter`,
+        });
+    }
+    invalidSegments.sort((a, b) => a.start - b.start);
+    if (invalidSegments.length > 0) {
+        let lastEnd = 0;
+        const underline = invalidSegments.reduce((acc, segment) => {
+            const spaces = ' '.repeat(segment.start - lastEnd);
+            const arrows = '^'.repeat(segment.length);
+            lastEnd = segment.start + segment.length;
+            return acc + spaces + arrows;
+        }, '');
+        throw new GeminiNextGenAPIClientError(`Path parameters result in path with invalid segments:\n${invalidSegments
+            .map((e) => e.error)
+            .join('\n')}\n${path}\n${underline}`);
+    }
+    return path;
+});
+/**
+ * URI-encodes path params and ensures no unsafe /./ or /../ path segments are introduced.
+ */
+const path = /* @__PURE__ */ createPathTagFunction(encodeURIPath);
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class BaseInteractions extends APIResource {
+    create(params, options) {
+        var _a;
+        const { api_version = this._client.apiVersion } = params, body = __rest(params, ["api_version"]);
+        if ('model' in body && 'agent_config' in body) {
+            throw new GeminiNextGenAPIClientError(`Invalid request: specified \`model\` and \`agent_config\`. If specifying \`model\`, use \`generation_config\`.`);
+        }
+        if ('agent' in body && 'generation_config' in body) {
+            throw new GeminiNextGenAPIClientError(`Invalid request: specified \`agent\` and \`generation_config\`. If specifying \`agent\`, use \`agent_config\`.`);
+        }
+        return this._client.post(path `/${api_version}/interactions`, Object.assign(Object.assign({ body }, options), { stream: (_a = params.stream) !== null && _a !== void 0 ? _a : false }));
+    }
+    /**
+     * Deletes the interaction by id.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.delete('id');
+     * ```
+     */
+    delete(id, params = {}, options) {
+        const { api_version = this._client.apiVersion } = params !== null && params !== void 0 ? params : {};
+        return this._client.delete(path `/${api_version}/interactions/${id}`, options);
+    }
+    /**
+     * Cancels an interaction by id. This only applies to background interactions that are still running.
+     *
+     * @example
+     * ```ts
+     * const interaction = await client.interactions.cancel('id');
+     * ```
+     */
+    cancel(id, params = {}, options) {
+        const { api_version = this._client.apiVersion } = params !== null && params !== void 0 ? params : {};
+        return this._client.post(path `/${api_version}/interactions/${id}/cancel`, options);
+    }
+    get(id, params = {}, options) {
+        var _a;
+        const _b = params !== null && params !== void 0 ? params : {}, { api_version = this._client.apiVersion } = _b, query = __rest(_b, ["api_version"]);
+        return this._client.get(path `/${api_version}/interactions/${id}`, Object.assign(Object.assign({ query }, options), { stream: (_a = params === null || params === void 0 ? void 0 : params.stream) !== null && _a !== void 0 ? _a : false }));
+    }
+}
+BaseInteractions._key = Object.freeze(['interactions']);
+class Interactions extends BaseInteractions {
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+function concatBytes(buffers) {
+    let length = 0;
+    for (const buffer of buffers) {
+        length += buffer.length;
+    }
+    const output = new Uint8Array(length);
+    let index = 0;
+    for (const buffer of buffers) {
+        output.set(buffer, index);
+        index += buffer.length;
+    }
+    return output;
+}
+let encodeUTF8_;
+function encodeUTF8(str) {
+    let encoder;
+    return (encodeUTF8_ !== null && encodeUTF8_ !== void 0 ? encodeUTF8_ : ((encoder = new globalThis.TextEncoder()), (encodeUTF8_ = encoder.encode.bind(encoder))))(str);
+}
+let decodeUTF8_;
+function decodeUTF8(bytes) {
+    let decoder;
+    return (decodeUTF8_ !== null && decodeUTF8_ !== void 0 ? decodeUTF8_ : ((decoder = new globalThis.TextDecoder()), (decodeUTF8_ = decoder.decode.bind(decoder))))(bytes);
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A re-implementation of httpx's `LineDecoder` in Python that handles incrementally
+ * reading lines from text.
+ *
+ * https://github.com/encode/httpx/blob/920333ea98118e9cf617f246905d7b202510941c/httpx/_decoders.py#L258
+ */
+class LineDecoder {
+    constructor() {
+        this.buffer = new Uint8Array();
+        this.carriageReturnIndex = null;
+    }
+    decode(chunk) {
+        if (chunk == null) {
+            return [];
+        }
+        const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+            : typeof chunk === 'string' ? encodeUTF8(chunk)
+                : chunk;
+        this.buffer = concatBytes([this.buffer, binaryChunk]);
+        const lines = [];
+        let patternIndex;
+        while ((patternIndex = findNewlineIndex(this.buffer, this.carriageReturnIndex)) != null) {
+            if (patternIndex.carriage && this.carriageReturnIndex == null) {
+                // skip until we either get a corresponding `\n`, a new `\r` or nothing
+                this.carriageReturnIndex = patternIndex.index;
+                continue;
+            }
+            // we got double \r or \rtext\n
+            if (this.carriageReturnIndex != null &&
+                (patternIndex.index !== this.carriageReturnIndex + 1 || patternIndex.carriage)) {
+                lines.push(decodeUTF8(this.buffer.subarray(0, this.carriageReturnIndex - 1)));
+                this.buffer = this.buffer.subarray(this.carriageReturnIndex);
+                this.carriageReturnIndex = null;
+                continue;
+            }
+            const endIndex = this.carriageReturnIndex !== null ? patternIndex.preceding - 1 : patternIndex.preceding;
+            const line = decodeUTF8(this.buffer.subarray(0, endIndex));
+            lines.push(line);
+            this.buffer = this.buffer.subarray(patternIndex.index);
+            this.carriageReturnIndex = null;
+        }
+        return lines;
+    }
+    flush() {
+        if (!this.buffer.length) {
+            return [];
+        }
+        return this.decode('\n');
+    }
+}
+// prettier-ignore
+LineDecoder.NEWLINE_CHARS = new Set(['\n', '\r']);
+LineDecoder.NEWLINE_REGEXP = /\r\n|[\n\r]/g;
+/**
+ * This function searches the buffer for the end patterns, (\r or \n)
+ * and returns an object with the index preceding the matched newline and the
+ * index after the newline char. `null` is returned if no new line is found.
+ *
+ * ```ts
+ * findNewLineIndex('abc\ndef') -> { preceding: 2, index: 3 }
+ * ```
+ */
+function findNewlineIndex(buffer, startIndex) {
+    const newline = 0x0a; // \n
+    const carriage = 0x0d; // \r
+    for (let i = startIndex !== null && startIndex !== void 0 ? startIndex : 0; i < buffer.length; i++) {
+        if (buffer[i] === newline) {
+            return { preceding: i, index: i + 1, carriage: false };
+        }
+        if (buffer[i] === carriage) {
+            return { preceding: i, index: i + 1, carriage: true };
+        }
+    }
+    return null;
+}
+function findDoubleNewlineIndex(buffer) {
+    // This function searches the buffer for the end patterns (\r\r, \n\n, \r\n\r\n)
+    // and returns the index right after the first occurrence of any pattern,
+    // or -1 if none of the patterns are found.
+    const newline = 0x0a; // \n
+    const carriage = 0x0d; // \r
+    for (let i = 0; i < buffer.length - 1; i++) {
+        if (buffer[i] === newline && buffer[i + 1] === newline) {
+            // \n\n
+            return i + 2;
+        }
+        if (buffer[i] === carriage && buffer[i + 1] === carriage) {
+            // \r\r
+            return i + 2;
+        }
+        if (buffer[i] === carriage &&
+            buffer[i + 1] === newline &&
+            i + 3 < buffer.length &&
+            buffer[i + 2] === carriage &&
+            buffer[i + 3] === newline) {
+            // \r\n\r\n
+            return i + 4;
+        }
+    }
+    return -1;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+const levelNumbers = {
+    off: 0,
+    error: 200,
+    warn: 300,
+    info: 400,
+    debug: 500,
+};
+const parseLogLevel = (maybeLevel, sourceName, client) => {
+    if (!maybeLevel) {
+        return undefined;
+    }
+    if (hasOwn(levelNumbers, maybeLevel)) {
+        return maybeLevel;
+    }
+    loggerFor(client).warn(`${sourceName} was set to ${JSON.stringify(maybeLevel)}, expected one of ${JSON.stringify(Object.keys(levelNumbers))}`);
+    return undefined;
+};
+function noop() { }
+function makeLogFn(fnLevel, logger, logLevel) {
+    if (!logger || levelNumbers[fnLevel] > levelNumbers[logLevel]) {
+        return noop;
+    }
+    else {
+        // Don't wrap logger functions, we want the stacktrace intact!
+        return logger[fnLevel].bind(logger);
+    }
+}
+const noopLogger = {
+    error: noop,
+    warn: noop,
+    info: noop,
+    debug: noop,
+};
+let cachedLoggers = /* @__PURE__ */ new WeakMap();
+function loggerFor(client) {
+    var _a;
+    const logger = client.logger;
+    const logLevel = (_a = client.logLevel) !== null && _a !== void 0 ? _a : 'off';
+    if (!logger) {
+        return noopLogger;
+    }
+    const cachedLogger = cachedLoggers.get(logger);
+    if (cachedLogger && cachedLogger[0] === logLevel) {
+        return cachedLogger[1];
+    }
+    const levelLogger = {
+        error: makeLogFn('error', logger, logLevel),
+        warn: makeLogFn('warn', logger, logLevel),
+        info: makeLogFn('info', logger, logLevel),
+        debug: makeLogFn('debug', logger, logLevel),
+    };
+    cachedLoggers.set(logger, [logLevel, levelLogger]);
+    return levelLogger;
+}
+const formatRequestDetails = (details) => {
+    if (details.options) {
+        details.options = Object.assign({}, details.options);
+        delete details.options['headers']; // redundant + leaks internals
+    }
+    if (details.headers) {
+        details.headers = Object.fromEntries((details.headers instanceof Headers ? [...details.headers] : Object.entries(details.headers)).map(([name, value]) => [
+            name,
+            (name.toLowerCase() === 'x-goog-api-key' ||
+                name.toLowerCase() === 'authorization' ||
+                name.toLowerCase() === 'cookie' ||
+                name.toLowerCase() === 'set-cookie') ?
+                '***'
+                : value,
+        ]));
+    }
+    if ('retryOfRequestLogID' in details) {
+        if (details.retryOfRequestLogID) {
+            details.retryOf = details.retryOfRequestLogID;
+        }
+        delete details.retryOfRequestLogID;
+    }
+    return details;
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+class Stream {
+    constructor(iterator, controller, client) {
+        this.iterator = iterator;
+        this.controller = controller;
+        this.client = client;
+    }
+    static fromSSEResponse(response, controller, client) {
+        let consumed = false;
+        const logger = client ? loggerFor(client) : console;
+        function iterator() {
+            return __asyncGenerator(this, arguments, function* iterator_1() {
+                var _a, e_1, _b, _c;
+                if (consumed) {
+                    throw new GeminiNextGenAPIClientError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+                }
+                consumed = true;
+                let done = false;
+                try {
+                    try {
+                        for (var _d = true, _e = __asyncValues(_iterSSEMessages(response, controller)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const sse = _c;
+                            if (done)
+                                continue;
+                            if (sse.data.startsWith('[DONE]')) {
+                                done = true;
+                                continue;
+                            }
+                            else {
+                                try {
+                                    // @ts-ignore
+                                    yield yield __await(JSON.parse(sse.data));
+                                }
+                                catch (e) {
+                                    logger.error(`Could not parse message into JSON:`, sse.data);
+                                    logger.error(`From chunk:`, sse.raw);
+                                    throw e;
+                                }
+                            }
+                        }
+                    }
+                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                        }
+                        finally { if (e_1) throw e_1.error; }
+                    }
+                    done = true;
+                }
+                catch (e) {
+                    // If the user calls `stream.controller.abort()`, we should exit without throwing.
+                    if (isAbortError(e))
+                        return yield __await(void 0);
+                    throw e;
+                }
+                finally {
+                    // If the user `break`s, abort the ongoing request.
+                    if (!done)
+                        controller.abort();
+                }
+            });
+        }
+        return new Stream(iterator, controller, client);
+    }
+    /**
+     * Generates a Stream from a newline-separated ReadableStream
+     * where each item is a JSON value.
+     */
+    static fromReadableStream(readableStream, controller, client) {
+        let consumed = false;
+        function iterLines() {
+            return __asyncGenerator(this, arguments, function* iterLines_1() {
+                var _a, e_2, _b, _c;
+                const lineDecoder = new LineDecoder();
+                const iter = ReadableStreamToAsyncIterable(readableStream);
+                try {
+                    for (var _d = true, iter_1 = __asyncValues(iter), iter_1_1; iter_1_1 = yield __await(iter_1.next()), _a = iter_1_1.done, !_a; _d = true) {
+                        _c = iter_1_1.value;
+                        _d = false;
+                        const chunk = _c;
+                        for (const line of lineDecoder.decode(chunk)) {
+                            yield yield __await(line);
+                        }
+                    }
+                }
+                catch (e_2_1) { e_2 = { error: e_2_1 }; }
+                finally {
+                    try {
+                        if (!_d && !_a && (_b = iter_1.return)) yield __await(_b.call(iter_1));
+                    }
+                    finally { if (e_2) throw e_2.error; }
+                }
+                for (const line of lineDecoder.flush()) {
+                    yield yield __await(line);
+                }
+            });
+        }
+        function iterator() {
+            return __asyncGenerator(this, arguments, function* iterator_2() {
+                var _a, e_3, _b, _c;
+                if (consumed) {
+                    throw new GeminiNextGenAPIClientError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+                }
+                consumed = true;
+                let done = false;
+                try {
+                    try {
+                        for (var _d = true, _e = __asyncValues(iterLines()), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                            _c = _f.value;
+                            _d = false;
+                            const line = _c;
+                            if (done)
+                                continue;
+                            // @ts-ignore
+                            if (line)
+                                yield yield __await(JSON.parse(line));
+                        }
+                    }
+                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    finally {
+                        try {
+                            if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                        }
+                        finally { if (e_3) throw e_3.error; }
+                    }
+                    done = true;
+                }
+                catch (e) {
+                    // If the user calls `stream.controller.abort()`, we should exit without throwing.
+                    if (isAbortError(e))
+                        return yield __await(void 0);
+                    throw e;
+                }
+                finally {
+                    // If the user `break`s, abort the ongoing request.
+                    if (!done)
+                        controller.abort();
+                }
+            });
+        }
+        return new Stream(iterator, controller, client);
+    }
+    [Symbol.asyncIterator]() {
+        return this.iterator();
+    }
+    /**
+     * Splits the stream into two streams which can be
+     * independently read from at different speeds.
+     */
+    tee() {
+        const left = [];
+        const right = [];
+        const iterator = this.iterator();
+        const teeIterator = (queue) => {
+            return {
+                next: () => {
+                    if (queue.length === 0) {
+                        const result = iterator.next();
+                        left.push(result);
+                        right.push(result);
+                    }
+                    return queue.shift();
+                },
+            };
+        };
+        return [
+            new Stream(() => teeIterator(left), this.controller, this.client),
+            new Stream(() => teeIterator(right), this.controller, this.client),
+        ];
+    }
+    /**
+     * Converts this stream to a newline-separated ReadableStream of
+     * JSON stringified values in the stream
+     * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+     */
+    toReadableStream() {
+        const self = this;
+        let iter;
+        return makeReadableStream({
+            async start() {
+                iter = self[Symbol.asyncIterator]();
+            },
+            async pull(ctrl) {
+                try {
+                    const { value, done } = await iter.next();
+                    if (done)
+                        return ctrl.close();
+                    const bytes = encodeUTF8(JSON.stringify(value) + '\n');
+                    ctrl.enqueue(bytes);
+                }
+                catch (err) {
+                    ctrl.error(err);
+                }
+            },
+            async cancel() {
+                var _a;
+                await ((_a = iter.return) === null || _a === void 0 ? void 0 : _a.call(iter));
+            },
+        });
+    }
+}
+function _iterSSEMessages(response, controller) {
+    return __asyncGenerator(this, arguments, function* _iterSSEMessages_1() {
+        var _a, e_4, _b, _c;
+        if (!response.body) {
+            controller.abort();
+            if (typeof globalThis.navigator !== 'undefined' &&
+                globalThis.navigator.product === 'ReactNative') {
+                throw new GeminiNextGenAPIClientError(`The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`);
+            }
+            throw new GeminiNextGenAPIClientError(`Attempted to iterate over a response with no body`);
+        }
+        const sseDecoder = new SSEDecoder();
+        const lineDecoder = new LineDecoder();
+        const iter = ReadableStreamToAsyncIterable(response.body);
+        try {
+            for (var _d = true, _e = __asyncValues(iterSSEChunks(iter)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                _c = _f.value;
+                _d = false;
+                const sseChunk = _c;
+                for (const line of lineDecoder.decode(sseChunk)) {
+                    const sse = sseDecoder.decode(line);
+                    if (sse)
+                        yield yield __await(sse);
+                }
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        for (const line of lineDecoder.flush()) {
+            const sse = sseDecoder.decode(line);
+            if (sse)
+                yield yield __await(sse);
+        }
+    });
+}
+/**
+ * Given an async iterable iterator, iterates over it and yields full
+ * SSE chunks, i.e. yields when a double new-line is encountered.
+ */
+function iterSSEChunks(iterator) {
+    return __asyncGenerator(this, arguments, function* iterSSEChunks_1() {
+        var _a, e_5, _b, _c;
+        let data = new Uint8Array();
+        try {
+            for (var _d = true, iterator_3 = __asyncValues(iterator), iterator_3_1; iterator_3_1 = yield __await(iterator_3.next()), _a = iterator_3_1.done, !_a; _d = true) {
+                _c = iterator_3_1.value;
+                _d = false;
+                const chunk = _c;
+                if (chunk == null) {
+                    continue;
+                }
+                const binaryChunk = chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+                    : typeof chunk === 'string' ? encodeUTF8(chunk)
+                        : chunk;
+                let newData = new Uint8Array(data.length + binaryChunk.length);
+                newData.set(data);
+                newData.set(binaryChunk, data.length);
+                data = newData;
+                let patternIndex;
+                while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
+                    yield yield __await(data.slice(0, patternIndex));
+                    data = data.slice(patternIndex);
+                }
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (!_d && !_a && (_b = iterator_3.return)) yield __await(_b.call(iterator_3));
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        if (data.length > 0) {
+            yield yield __await(data);
+        }
+    });
+}
+class SSEDecoder {
+    constructor() {
+        this.event = null;
+        this.data = [];
+        this.chunks = [];
+    }
+    decode(line) {
+        if (line.endsWith('\r')) {
+            line = line.substring(0, line.length - 1);
+        }
+        if (!line) {
+            // empty line and we didn't previously encounter any messages
+            if (!this.event && !this.data.length)
+                return null;
+            const sse = {
+                event: this.event,
+                data: this.data.join('\n'),
+                raw: this.chunks,
+            };
+            this.event = null;
+            this.data = [];
+            this.chunks = [];
+            return sse;
+        }
+        this.chunks.push(line);
+        if (line.startsWith(':')) {
+            return null;
+        }
+        let [fieldname, _, value] = partition(line, ':');
+        if (value.startsWith(' ')) {
+            value = value.substring(1);
+        }
+        if (fieldname === 'event') {
+            this.event = value;
+        }
+        else if (fieldname === 'data') {
+            this.data.push(value);
+        }
+        return null;
+    }
+}
+function partition(str, delimiter) {
+    const index = str.indexOf(delimiter);
+    if (index !== -1) {
+        return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+    }
+    return [str, '', ''];
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+async function defaultParseResponse(client, props) {
+    const { response, requestLogID, retryOfRequestLogID, startTime } = props;
+    const body = await (async () => {
+        var _a;
+        if (props.options.stream) {
+            loggerFor(client).debug('response', response.status, response.url, response.headers, response.body);
+            // Note: there is an invariant here that isn't represented in the type system
+            // that if you set `stream: true` the response type must also be `Stream<T>`
+            if (props.options.__streamClass) {
+                return props.options.__streamClass.fromSSEResponse(response, props.controller, client);
+            }
+            return Stream.fromSSEResponse(response, props.controller, client);
+        }
+        // fetch refuses to read the body when the status code is 204.
+        if (response.status === 204) {
+            return null;
+        }
+        if (props.options.__binaryResponse) {
+            return response;
+        }
+        const contentType = response.headers.get('content-type');
+        const mediaType = (_a = contentType === null || contentType === void 0 ? void 0 : contentType.split(';')[0]) === null || _a === void 0 ? void 0 : _a.trim();
+        const isJSON = (mediaType === null || mediaType === void 0 ? void 0 : mediaType.includes('application/json')) || (mediaType === null || mediaType === void 0 ? void 0 : mediaType.endsWith('+json'));
+        if (isJSON) {
+            const json = await response.json();
+            return json;
+        }
+        const text = await response.text();
+        return text;
+    })();
+    loggerFor(client).debug(`[${requestLogID}] response parsed`, formatRequestDetails({
+        retryOfRequestLogID,
+        url: response.url,
+        status: response.status,
+        body,
+        durationMs: Date.now() - startTime,
+    }));
+    return body;
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * A subclass of `Promise` providing additional helper methods
+ * for interacting with the SDK.
+ */
+class APIPromise extends Promise {
+    constructor(client, responsePromise, parseResponse = defaultParseResponse) {
+        super((resolve) => {
+            // this is maybe a bit weird but this has to be a no-op to not implicitly
+            // parse the response body; instead .then, .catch, .finally are overridden
+            // to parse the response
+            resolve(null);
+        });
+        this.responsePromise = responsePromise;
+        this.parseResponse = parseResponse;
+        this.client = client;
+    }
+    _thenUnwrap(transform) {
+        return new APIPromise(this.client, this.responsePromise, async (client, props) => transform(await this.parseResponse(client, props), props));
+    }
+    /**
+     * Gets the raw `Response` instance instead of parsing the response
+     * data.
+     *
+     * If you want to parse the response body but still get the `Response`
+     * instance, you can use {@link withResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    asResponse() {
+        return this.responsePromise.then((p) => p.response);
+    }
+    /**
+     * Gets the parsed response data and the raw `Response` instance.
+     *
+     * If you just want to get the raw `Response` instance without parsing it,
+     * you can use {@link asResponse()}.
+     *
+     * 👋 Getting the wrong TypeScript type for `Response`?
+     * Try setting `"moduleResolution": "NodeNext"` or add `"lib": ["DOM"]`
+     * to your `tsconfig.json`.
+     */
+    async withResponse() {
+        const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+        return { data, response };
+    }
+    parse() {
+        if (!this.parsedPromise) {
+            this.parsedPromise = this.responsePromise.then((data) => this.parseResponse(this.client, data));
+        }
+        return this.parsedPromise;
+    }
+    then(onfulfilled, onrejected) {
+        return this.parse().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.parse().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.parse().finally(onfinally);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+const brand_privateNullableHeaders = /* @__PURE__ */ Symbol('brand.privateNullableHeaders');
+function* iterateHeaders(headers) {
+    if (!headers)
+        return;
+    if (brand_privateNullableHeaders in headers) {
+        const { values, nulls } = headers;
+        yield* values.entries();
+        for (const name of nulls) {
+            yield [name, null];
+        }
+        return;
+    }
+    let shouldClear = false;
+    let iter;
+    if (headers instanceof Headers) {
+        iter = headers.entries();
+    }
+    else if (isReadonlyArray(headers)) {
+        iter = headers;
+    }
+    else {
+        shouldClear = true;
+        iter = Object.entries(headers !== null && headers !== void 0 ? headers : {});
+    }
+    for (let row of iter) {
+        const name = row[0];
+        if (typeof name !== 'string')
+            throw new TypeError('expected header name to be a string');
+        const values = isReadonlyArray(row[1]) ? row[1] : [row[1]];
+        let didClear = false;
+        for (const value of values) {
+            if (value === undefined)
+                continue;
+            // Objects keys always overwrite older headers, they never append.
+            // Yield a null to clear the header before adding the new values.
+            if (shouldClear && !didClear) {
+                didClear = true;
+                yield [name, null];
+            }
+            yield [name, value];
+        }
+    }
+}
+const buildHeaders = (newHeaders) => {
+    const targetHeaders = new Headers();
+    const nullHeaders = new Set();
+    for (const headers of newHeaders) {
+        const seenHeaders = new Set();
+        for (const [name, value] of iterateHeaders(headers)) {
+            const lowerName = name.toLowerCase();
+            if (!seenHeaders.has(lowerName)) {
+                targetHeaders.delete(name);
+                seenHeaders.add(lowerName);
+            }
+            if (value === null) {
+                targetHeaders.delete(name);
+                nullHeaders.add(lowerName);
+            }
+            else {
+                targetHeaders.append(name, value);
+                nullHeaders.delete(lowerName);
+            }
+        }
+    }
+    return { [brand_privateNullableHeaders]: true, values: targetHeaders, nulls: nullHeaders };
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+/**
+ * Read an environment variable.
+ *
+ * Trims beginning and trailing whitespace.
+ *
+ * Will return undefined if the environment variable doesn't exist or cannot be accessed.
+ */
+const readEnv = (env) => {
+    var _a, _b, _c, _d, _e, _f;
+    if (typeof globalThis.process !== 'undefined') {
+        return (_c = (_b = (_a = globalThis.process.env) === null || _a === void 0 ? void 0 : _a[env]) === null || _b === void 0 ? void 0 : _b.trim()) !== null && _c !== void 0 ? _c : undefined;
+    }
+    if (typeof globalThis.Deno !== 'undefined') {
+        return (_f = (_e = (_d = globalThis.Deno.env) === null || _d === void 0 ? void 0 : _d.get) === null || _e === void 0 ? void 0 : _e.call(_d, env)) === null || _f === void 0 ? void 0 : _f.trim();
+    }
+    return undefined;
+};
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var _a;
+/**
+ * Base class for Gemini Next Gen API API clients.
+ */
+class BaseGeminiNextGenAPIClient {
+    /**
+     * API Client for interfacing with the Gemini Next Gen API API.
+     *
+     * @param {string | null | undefined} [opts.apiKey=process.env['GEMINI_API_KEY'] ?? null]
+     * @param {string | undefined} [opts.apiVersion=v1beta]
+     * @param {string} [opts.baseURL=process.env['GEMINI_NEXT_GEN_API_BASE_URL'] ?? https://generativelanguage.googleapis.com] - Override the default base URL for the API.
+     * @param {number} [opts.timeout=1 minute] - The maximum amount of time (in milliseconds) the client will wait for a response before timing out.
+     * @param {MergedRequestInit} [opts.fetchOptions] - Additional `RequestInit` options to be passed to `fetch` calls.
+     * @param {Fetch} [opts.fetch] - Specify a custom `fetch` function implementation.
+     * @param {number} [opts.maxRetries=2] - The maximum number of times the client will retry a request.
+     * @param {HeadersLike} opts.defaultHeaders - Default headers to include with every request to the API.
+     * @param {Record<string, string | undefined>} opts.defaultQuery - Default query parameters to include with every request to the API.
+     */
+    constructor(_b) {
+        var _c, _d, _e, _f, _g, _h, _j;
+        var { baseURL = readEnv('GEMINI_NEXT_GEN_API_BASE_URL'), apiKey = (_c = readEnv('GEMINI_API_KEY')) !== null && _c !== void 0 ? _c : null, apiVersion = 'v1beta' } = _b, opts = __rest(_b, ["baseURL", "apiKey", "apiVersion"]);
+        const options = Object.assign(Object.assign({ apiKey,
+            apiVersion }, opts), { baseURL: baseURL || `https://generativelanguage.googleapis.com` });
+        this.baseURL = options.baseURL;
+        this.timeout = (_d = options.timeout) !== null && _d !== void 0 ? _d : BaseGeminiNextGenAPIClient.DEFAULT_TIMEOUT /* 1 minute */;
+        this.logger = (_e = options.logger) !== null && _e !== void 0 ? _e : console;
+        const defaultLogLevel = 'warn';
+        // Set default logLevel early so that we can log a warning in parseLogLevel.
+        this.logLevel = defaultLogLevel;
+        this.logLevel =
+            (_g = (_f = parseLogLevel(options.logLevel, 'ClientOptions.logLevel', this)) !== null && _f !== void 0 ? _f : parseLogLevel(readEnv('GEMINI_NEXT_GEN_API_LOG'), "process.env['GEMINI_NEXT_GEN_API_LOG']", this)) !== null && _g !== void 0 ? _g : defaultLogLevel;
+        this.fetchOptions = options.fetchOptions;
+        this.maxRetries = (_h = options.maxRetries) !== null && _h !== void 0 ? _h : 2;
+        this.fetch = (_j = options.fetch) !== null && _j !== void 0 ? _j : getDefaultFetch();
+        this.encoder = FallbackEncoder;
+        this._options = options;
+        this.apiKey = apiKey;
+        this.apiVersion = apiVersion;
+        this.clientAdapter = options.clientAdapter;
+    }
+    /**
+     * Create a new client instance re-using the same options given to the current client with optional overriding.
+     */
+    withOptions(options) {
+        const client = new this.constructor(Object.assign(Object.assign(Object.assign({}, this._options), { baseURL: this.baseURL, maxRetries: this.maxRetries, timeout: this.timeout, logger: this.logger, logLevel: this.logLevel, fetch: this.fetch, fetchOptions: this.fetchOptions, apiKey: this.apiKey, apiVersion: this.apiVersion }), options));
+        return client;
+    }
+    /**
+     * Check whether the base URL is set to its default.
+     */
+    baseURLOverridden() {
+        return this.baseURL !== 'https://generativelanguage.googleapis.com';
+    }
+    defaultQuery() {
+        return this._options.defaultQuery;
+    }
+    validateHeaders({ values, nulls }) {
+        // The headers object handles case insensitivity.
+        if (values.has('authorization') || values.has('x-goog-api-key')) {
+            return;
+        }
+        if (this.apiKey && values.get('x-goog-api-key')) {
+            return;
+        }
+        if (nulls.has('x-goog-api-key')) {
+            return;
+        }
+        throw new Error('Could not resolve authentication method. Expected the apiKey to be set. Or for the "x-goog-api-key" headers to be explicitly omitted');
+    }
+    async authHeaders(opts) {
+        const existingHeaders = buildHeaders([opts.headers]);
+        if (existingHeaders.values.has('authorization') || existingHeaders.values.has('x-goog-api-key')) {
+            return undefined;
+        }
+        if (this.apiKey) {
+            return buildHeaders([{ 'x-goog-api-key': this.apiKey }]);
+        }
+        if (this.clientAdapter.isVertexAI()) {
+            return buildHeaders([await this.clientAdapter.getAuthHeaders()]);
+        }
+        return undefined;
+    }
+    /**
+     * Basic re-implementation of `qs.stringify` for primitive types.
      */
-    async create(params) {
-        var _a, _b;
-        let response;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
+    stringifyQuery(query) {
+        return Object.entries(query)
+            .filter(([_, value]) => typeof value !== 'undefined')
+            .map(([key, value]) => {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+                return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+            }
+            if (value === null) {
+                return `${encodeURIComponent(key)}=`;
+            }
+            throw new GeminiNextGenAPIClientError(`Cannot stringify type ${typeof value}; Expected string, number, boolean, or null. If you need to pass nested query parameters, you can manually encode them, e.g. { query: { 'foo[key1]': value1, 'foo[key2]': value2 } }, and please open a GitHub issue requesting better support for your use case.`);
+        })
+            .join('&');
+    }
+    getUserAgent() {
+        return `${this.constructor.name}/JS ${VERSION}`;
+    }
+    defaultIdempotencyKey() {
+        return `stainless-node-retry-${uuid4()}`;
+    }
+    makeStatusError(status, error, message, headers) {
+        return APIError.generate(status, error, message, headers);
+    }
+    buildURL(path, query, defaultBaseURL) {
+        const baseURL = (!this.baseURLOverridden() && defaultBaseURL) || this.baseURL;
+        const url = isAbsoluteURL(path) ?
+            new URL(path)
+            : new URL(baseURL + (baseURL.endsWith('/') && path.startsWith('/') ? path.slice(1) : path));
+        const defaultQuery = this.defaultQuery();
+        if (!isEmptyObj(defaultQuery)) {
+            query = Object.assign(Object.assign({}, defaultQuery), query);
         }
-        else {
-            const body = createFileSearchStoreParametersToMldev(params);
-            path = formatMap('fileSearchStores', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            response = this.apiClient
-                .request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'POST',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            })
-                .then((httpResponse) => {
-                return httpResponse.json();
-            });
-            return response.then((resp) => {
-                return resp;
-            });
+        if (typeof query === 'object' && query && !Array.isArray(query)) {
+            url.search = this.stringifyQuery(query);
         }
+        return url.toString();
     }
     /**
-     * Gets a File Search Store.
-     *
-     * @param params - The parameters for getting a File Search Store.
-     * @return FileSearchStore.
+     * Used as a callback for mutating the given `FinalRequestOptions` object.
+  
      */
-    async get(params) {
-        var _a, _b;
-        let response;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
-        }
-        else {
-            const body = getFileSearchStoreParametersToMldev(params);
-            path = formatMap('{name}', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            response = this.apiClient
-                .request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'GET',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            })
-                .then((httpResponse) => {
-                return httpResponse.json();
-            });
-            return response.then((resp) => {
-                return resp;
-            });
+    async prepareOptions(options) {
+        if (this.clientAdapter &&
+            this.clientAdapter.isVertexAI() &&
+            !options.path.startsWith(`/${this.apiVersion}/projects/`)) {
+            const oldPath = options.path.slice(this.apiVersion.length + 1);
+            options.path = `/${this.apiVersion}/projects/${this.clientAdapter.getProject()}/locations/${this.clientAdapter.getLocation()}${oldPath}`;
         }
     }
     /**
-     * Deletes a File Search Store.
+     * Used as a callback for mutating the given `RequestInit` object.
      *
-     * @param params - The parameters for deleting a File Search Store.
+     * This is useful for cases where you want to add certain headers based off of
+     * the request properties, e.g. `method` or `url`.
      */
-    async delete(params) {
-        var _a, _b;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
+    async prepareRequest(request, { url, options }) { }
+    get(path, opts) {
+        return this.methodRequest('get', path, opts);
+    }
+    post(path, opts) {
+        return this.methodRequest('post', path, opts);
+    }
+    patch(path, opts) {
+        return this.methodRequest('patch', path, opts);
+    }
+    put(path, opts) {
+        return this.methodRequest('put', path, opts);
+    }
+    delete(path, opts) {
+        return this.methodRequest('delete', path, opts);
+    }
+    methodRequest(method, path, opts) {
+        return this.request(Promise.resolve(opts).then((opts) => {
+            return Object.assign({ method, path }, opts);
+        }));
+    }
+    request(options, remainingRetries = null) {
+        return new APIPromise(this, this.makeRequest(options, remainingRetries, undefined));
+    }
+    async makeRequest(optionsInput, retriesRemaining, retryOfRequestLogID) {
+        var _b, _c, _d;
+        const options = await optionsInput;
+        const maxRetries = (_b = options.maxRetries) !== null && _b !== void 0 ? _b : this.maxRetries;
+        if (retriesRemaining == null) {
+            retriesRemaining = maxRetries;
         }
-        else {
-            const body = deleteFileSearchStoreParametersToMldev(params);
-            path = formatMap('{name}', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            await this.apiClient.request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'DELETE',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            });
+        await this.prepareOptions(options);
+        const { req, url, timeout } = await this.buildRequest(options, {
+            retryCount: maxRetries - retriesRemaining,
+        });
+        await this.prepareRequest(req, { url, options });
+        /** Not an API request ID, just for correlating local log entries. */
+        const requestLogID = 'log_' + ((Math.random() * (1 << 24)) | 0).toString(16).padStart(6, '0');
+        const retryLogStr = retryOfRequestLogID === undefined ? '' : `, retryOf: ${retryOfRequestLogID}`;
+        const startTime = Date.now();
+        loggerFor(this).debug(`[${requestLogID}] sending request`, formatRequestDetails({
+            retryOfRequestLogID,
+            method: options.method,
+            url,
+            options,
+            headers: req.headers,
+        }));
+        if ((_c = options.signal) === null || _c === void 0 ? void 0 : _c.aborted) {
+            throw new APIUserAbortError();
+        }
+        const controller = new AbortController();
+        const response = await this.fetchWithTimeout(url, req, timeout, controller).catch(castToError);
+        const headersTime = Date.now();
+        if (response instanceof globalThis.Error) {
+            const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+            if ((_d = options.signal) === null || _d === void 0 ? void 0 : _d.aborted) {
+                throw new APIUserAbortError();
+            }
+            // detect native connection timeout errors
+            // deno throws "TypeError: error sending request for url (https://example/): client error (Connect): tcp connect error: Operation timed out (os error 60): Operation timed out (os error 60)"
+            // undici throws "TypeError: fetch failed" with cause "ConnectTimeoutError: Connect Timeout Error (attempted address: example:443, timeout: 1ms)"
+            // others do not provide enough information to distinguish timeouts from other connection errors
+            const isTimeout = isAbortError(response) ||
+                /timed? ?out/i.test(String(response) + ('cause' in response ? String(response.cause) : ''));
+            if (retriesRemaining) {
+                loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - ${retryMessage}`);
+                loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (${retryMessage})`, formatRequestDetails({
+                    retryOfRequestLogID,
+                    url,
+                    durationMs: headersTime - startTime,
+                    message: response.message,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID !== null && retryOfRequestLogID !== void 0 ? retryOfRequestLogID : requestLogID);
+            }
+            loggerFor(this).info(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} - error; no more retries left`);
+            loggerFor(this).debug(`[${requestLogID}] connection ${isTimeout ? 'timed out' : 'failed'} (error; no more retries left)`, formatRequestDetails({
+                retryOfRequestLogID,
+                url,
+                durationMs: headersTime - startTime,
+                message: response.message,
+            }));
+            if (isTimeout) {
+                throw new APIConnectionTimeoutError();
+            }
+            throw new APIConnectionError({ cause: response });
+        }
+        const responseInfo = `[${requestLogID}${retryLogStr}] ${req.method} ${url} ${response.ok ? 'succeeded' : 'failed'} with status ${response.status} in ${headersTime - startTime}ms`;
+        if (!response.ok) {
+            const shouldRetry = await this.shouldRetry(response);
+            if (retriesRemaining && shouldRetry) {
+                const retryMessage = `retrying, ${retriesRemaining} attempts remaining`;
+                // We don't need the body of this response.
+                await CancelReadableStream(response.body);
+                loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+                loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+                    retryOfRequestLogID,
+                    url: response.url,
+                    status: response.status,
+                    headers: response.headers,
+                    durationMs: headersTime - startTime,
+                }));
+                return this.retryRequest(options, retriesRemaining, retryOfRequestLogID !== null && retryOfRequestLogID !== void 0 ? retryOfRequestLogID : requestLogID, response.headers);
+            }
+            const retryMessage = shouldRetry ? `error; no more retries left` : `error; not retryable`;
+            loggerFor(this).info(`${responseInfo} - ${retryMessage}`);
+            const errText = await response.text().catch((err) => castToError(err).message);
+            const errJSON = safeJSON(errText);
+            const errMessage = errJSON ? undefined : errText;
+            loggerFor(this).debug(`[${requestLogID}] response error (${retryMessage})`, formatRequestDetails({
+                retryOfRequestLogID,
+                url: response.url,
+                status: response.status,
+                headers: response.headers,
+                message: errMessage,
+                durationMs: Date.now() - startTime,
+            }));
+            // @ts-ignore
+            const err = this.makeStatusError(response.status, errJSON, errMessage, response.headers);
+            throw err;
+        }
+        loggerFor(this).info(responseInfo);
+        loggerFor(this).debug(`[${requestLogID}] response start`, formatRequestDetails({
+            retryOfRequestLogID,
+            url: response.url,
+            status: response.status,
+            headers: response.headers,
+            durationMs: headersTime - startTime,
+        }));
+        return { response, options, controller, requestLogID, retryOfRequestLogID, startTime };
+    }
+    async fetchWithTimeout(url, init, ms, controller) {
+        const _b = init || {}, { signal, method } = _b, options = __rest(_b, ["signal", "method"]);
+        if (signal)
+            signal.addEventListener('abort', () => controller.abort());
+        const timeout = setTimeout(() => controller.abort(), ms);
+        const isReadableBody = (globalThis.ReadableStream && options.body instanceof globalThis.ReadableStream) ||
+            (typeof options.body === 'object' && options.body !== null && Symbol.asyncIterator in options.body);
+        const fetchOptions = Object.assign(Object.assign(Object.assign({ signal: controller.signal }, (isReadableBody ? { duplex: 'half' } : {})), { method: 'GET' }), options);
+        if (method) {
+            // Custom methods like 'patch' need to be uppercased
+            // See https://github.com/nodejs/undici/issues/2294
+            fetchOptions.method = method.toUpperCase();
         }
-    }
-    async listInternal(params) {
-        var _a, _b;
-        let response;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
+        try {
+            // use undefined this binding; fetch errors if bound to something else in browser/cloudflare
+            return await this.fetch.call(undefined, url, fetchOptions);
         }
-        else {
-            const body = listFileSearchStoresParametersToMldev(params);
-            path = formatMap('fileSearchStores', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            response = this.apiClient
-                .request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'GET',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            })
-                .then((httpResponse) => {
-                return httpResponse.json();
-            });
-            return response.then((apiResponse) => {
-                const resp = listFileSearchStoresResponseFromMldev(apiResponse);
-                const typedResp = new ListFileSearchStoresResponse();
-                Object.assign(typedResp, resp);
-                return typedResp;
-            });
+        finally {
+            clearTimeout(timeout);
         }
     }
-    async uploadToFileSearchStoreInternal(params) {
-        var _a, _b;
-        let response;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
+    async shouldRetry(response) {
+        // Note this is not a standard header.
+        const shouldRetryHeader = response.headers.get('x-should-retry');
+        // If the server explicitly says whether or not to retry, obey.
+        if (shouldRetryHeader === 'true')
+            return true;
+        if (shouldRetryHeader === 'false')
+            return false;
+        // Retry on request timeouts.
+        if (response.status === 408)
+            return true;
+        // Retry on lock timeouts.
+        if (response.status === 409)
+            return true;
+        // Retry on rate limits.
+        if (response.status === 429)
+            return true;
+        // Retry internal errors.
+        if (response.status >= 500)
+            return true;
+        return false;
+    }
+    async retryRequest(options, retriesRemaining, requestLogID, responseHeaders) {
+        var _b;
+        let timeoutMillis;
+        // Note the `retry-after-ms` header may not be standard, but is a good idea and we'd like proactive support for it.
+        const retryAfterMillisHeader = responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders.get('retry-after-ms');
+        if (retryAfterMillisHeader) {
+            const timeoutMs = parseFloat(retryAfterMillisHeader);
+            if (!Number.isNaN(timeoutMs)) {
+                timeoutMillis = timeoutMs;
+            }
         }
-        else {
-            const body = uploadToFileSearchStoreParametersToMldev(params);
-            path = formatMap('upload/v1beta/{file_search_store_name}:uploadToFileSearchStore', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            response = this.apiClient
-                .request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'POST',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            })
-                .then((httpResponse) => {
-                return httpResponse.json();
-            });
-            return response.then((apiResponse) => {
-                const resp = uploadToFileSearchStoreResumableResponseFromMldev(apiResponse);
-                const typedResp = new UploadToFileSearchStoreResumableResponse();
-                Object.assign(typedResp, resp);
-                return typedResp;
-            });
+        // About the Retry-After header: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Retry-After
+        const retryAfterHeader = responseHeaders === null || responseHeaders === void 0 ? void 0 : responseHeaders.get('retry-after');
+        if (retryAfterHeader && !timeoutMillis) {
+            const timeoutSeconds = parseFloat(retryAfterHeader);
+            if (!Number.isNaN(timeoutSeconds)) {
+                timeoutMillis = timeoutSeconds * 1000;
+            }
+            else {
+                timeoutMillis = Date.parse(retryAfterHeader) - Date.now();
+            }
         }
-    }
-    /**
-     * Imports a File from File Service to a FileSearchStore.
-     *
-     * This is a long-running operation, see aip.dev/151
-     *
-     * @param params - The parameters for importing a file to a file search store.
-     * @return ImportFileOperation.
-     */
-    async importFile(params) {
-        var _a, _b;
-        let response;
-        let path = '';
-        let queryParams = {};
-        if (this.apiClient.isVertexAI()) {
-            throw new Error('This method is only supported by the Gemini Developer API.');
+        // If the API asks us to wait a certain amount of time (and it's a reasonable amount),
+        // just do what it says, but otherwise calculate a default
+        if (!(timeoutMillis && 0 <= timeoutMillis && timeoutMillis < 60 * 1000)) {
+            const maxRetries = (_b = options.maxRetries) !== null && _b !== void 0 ? _b : this.maxRetries;
+            timeoutMillis = this.calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries);
+        }
+        await sleep(timeoutMillis);
+        return this.makeRequest(options, retriesRemaining - 1, requestLogID);
+    }
+    calculateDefaultRetryTimeoutMillis(retriesRemaining, maxRetries) {
+        const initialRetryDelay = 0.5;
+        const maxRetryDelay = 8.0;
+        const numRetries = maxRetries - retriesRemaining;
+        // Apply exponential backoff, but not more than the max.
+        const sleepSeconds = Math.min(initialRetryDelay * Math.pow(2, numRetries), maxRetryDelay);
+        // Apply some jitter, take up to at most 25 percent of the retry time.
+        const jitter = 1 - Math.random() * 0.25;
+        return sleepSeconds * jitter * 1000;
+    }
+    async buildRequest(inputOptions, { retryCount = 0 } = {}) {
+        var _b, _c, _d;
+        const options = Object.assign({}, inputOptions);
+        const { method, path, query, defaultBaseURL } = options;
+        const url = this.buildURL(path, query, defaultBaseURL);
+        if ('timeout' in options)
+            validatePositiveInteger('timeout', options.timeout);
+        options.timeout = (_b = options.timeout) !== null && _b !== void 0 ? _b : this.timeout;
+        const { bodyHeaders, body } = this.buildBody({ options });
+        const reqHeaders = await this.buildHeaders({ options: inputOptions, method, bodyHeaders, retryCount });
+        const req = Object.assign(Object.assign(Object.assign(Object.assign(Object.assign({ method, headers: reqHeaders }, (options.signal && { signal: options.signal })), (globalThis.ReadableStream &&
+            body instanceof globalThis.ReadableStream && { duplex: 'half' })), (body && { body })), ((_c = this.fetchOptions) !== null && _c !== void 0 ? _c : {})), ((_d = options.fetchOptions) !== null && _d !== void 0 ? _d : {}));
+        return { req, url, timeout: options.timeout };
+    }
+    async buildHeaders({ options, method, bodyHeaders, retryCount, }) {
+        let idempotencyHeaders = {};
+        if (this.idempotencyHeader && method !== 'get') {
+            if (!options.idempotencyKey)
+                options.idempotencyKey = this.defaultIdempotencyKey();
+            idempotencyHeaders[this.idempotencyHeader] = options.idempotencyKey;
+        }
+        const authHeaders = await this.authHeaders(options);
+        let headers = buildHeaders([
+            idempotencyHeaders,
+            Object.assign(Object.assign({ Accept: 'application/json', 'User-Agent': this.getUserAgent(), 'X-Stainless-Retry-Count': String(retryCount) }, (options.timeout ? { 'X-Stainless-Timeout': String(Math.trunc(options.timeout / 1000)) } : {})), getPlatformHeaders()),
+            this._options.defaultHeaders,
+            bodyHeaders,
+            options.headers,
+            authHeaders,
+        ]);
+        this.validateHeaders(headers);
+        return headers.values;
+    }
+    buildBody({ options: { body, headers: rawHeaders } }) {
+        if (!body) {
+            return { bodyHeaders: undefined, body: undefined };
+        }
+        const headers = buildHeaders([rawHeaders]);
+        if (
+        // Pass raw type verbatim
+        ArrayBuffer.isView(body) ||
+            body instanceof ArrayBuffer ||
+            body instanceof DataView ||
+            (typeof body === 'string' &&
+                // Preserve legacy string encoding behavior for now
+                headers.values.has('content-type')) ||
+            // `Blob` is superset of `File`
+            (globalThis.Blob && body instanceof globalThis.Blob) ||
+            // `FormData` -> `multipart/form-data`
+            body instanceof FormData ||
+            // `URLSearchParams` -> `application/x-www-form-urlencoded`
+            body instanceof URLSearchParams ||
+            // Send chunked stream (each chunk has own `length`)
+            (globalThis.ReadableStream && body instanceof globalThis.ReadableStream)) {
+            return { bodyHeaders: undefined, body: body };
+        }
+        else if (typeof body === 'object' &&
+            (Symbol.asyncIterator in body ||
+                (Symbol.iterator in body && 'next' in body && typeof body.next === 'function'))) {
+            return { bodyHeaders: undefined, body: ReadableStreamFrom(body) };
         }
         else {
-            const body = importFileParametersToMldev(params);
-            path = formatMap('{file_search_store_name}:importFile', body['_url']);
-            queryParams = body['_query'];
-            delete body['_url'];
-            delete body['_query'];
-            response = this.apiClient
-                .request({
-                path: path,
-                queryParams: queryParams,
-                body: JSON.stringify(body),
-                httpMethod: 'POST',
-                httpOptions: (_a = params.config) === null || _a === void 0 ? void 0 : _a.httpOptions,
-                abortSignal: (_b = params.config) === null || _b === void 0 ? void 0 : _b.abortSignal,
-            })
-                .then((httpResponse) => {
-                return httpResponse.json();
-            });
-            return response.then((apiResponse) => {
-                const resp = importFileOperationFromMldev(apiResponse);
-                const typedResp = new ImportFileOperation();
-                Object.assign(typedResp, resp);
-                return typedResp;
-            });
+            return this.encoder({ body, headers });
         }
     }
 }
+BaseGeminiNextGenAPIClient.DEFAULT_TIMEOUT = 60000; // 1 minute
+/**
+ * API Client for interfacing with the Gemini Next Gen API API.
+ */
+class GeminiNextGenAPIClient extends BaseGeminiNextGenAPIClient {
+    constructor() {
+        super(...arguments);
+        this.interactions = new Interactions(this);
+    }
+}
+_a = GeminiNextGenAPIClient;
+GeminiNextGenAPIClient.GeminiNextGenAPIClient = _a;
+GeminiNextGenAPIClient.GeminiNextGenAPIClientError = GeminiNextGenAPIClientError;
+GeminiNextGenAPIClient.APIError = APIError;
+GeminiNextGenAPIClient.APIConnectionError = APIConnectionError;
+GeminiNextGenAPIClient.APIConnectionTimeoutError = APIConnectionTimeoutError;
+GeminiNextGenAPIClient.APIUserAbortError = APIUserAbortError;
+GeminiNextGenAPIClient.NotFoundError = NotFoundError;
+GeminiNextGenAPIClient.ConflictError = ConflictError;
+GeminiNextGenAPIClient.RateLimitError = RateLimitError;
+GeminiNextGenAPIClient.BadRequestError = BadRequestError;
+GeminiNextGenAPIClient.AuthenticationError = AuthenticationError;
+GeminiNextGenAPIClient.InternalServerError = InternalServerError;
+GeminiNextGenAPIClient.PermissionDeniedError = PermissionDeniedError;
+GeminiNextGenAPIClient.UnprocessableEntityError = UnprocessableEntityError;
+GeminiNextGenAPIClient.toFile = toFile;
+GeminiNextGenAPIClient.Interactions = Interactions;
 
 /**
  * @license
@@ -8691,7 +10736,7 @@ function generationConfigToVertex$1(fromObject) {
     }
     const fromSpeechConfig = getValueByPath(fromObject, ['speechConfig']);
     if (fromSpeechConfig != null) {
-        setValueByPath(toObject, ['speechConfig'], speechConfigToVertex$1(fromSpeechConfig));
+        setValueByPath(toObject, ['speechConfig'], fromSpeechConfig);
     }
     const fromStopSequences = getValueByPath(fromObject, [
         'stopSequences',
@@ -8858,6 +10903,9 @@ function liveConnectConfigToMldev$1(fromObject, parentObject) {
     if (parentObject !== undefined && fromProactivity != null) {
         setValueByPath(parentObject, ['setup', 'proactivity'], fromProactivity);
     }
+    if (getValueByPath(fromObject, ['explicitVadSignal']) !== undefined) {
+        throw new Error('explicitVadSignal parameter is not supported in Gemini API.');
+    }
     return toObject;
 }
 function liveConnectConfigToVertex(fromObject, parentObject) {
@@ -8904,7 +10952,7 @@ function liveConnectConfigToVertex(fromObject, parentObject) {
     }
     const fromSpeechConfig = getValueByPath(fromObject, ['speechConfig']);
     if (parentObject !== undefined && fromSpeechConfig != null) {
-        setValueByPath(parentObject, ['setup', 'generationConfig', 'speechConfig'], speechConfigToVertex$1(tLiveSpeechConfig(fromSpeechConfig)));
+        setValueByPath(parentObject, ['setup', 'generationConfig', 'speechConfig'], tLiveSpeechConfig(fromSpeechConfig));
     }
     const fromThinkingConfig = getValueByPath(fromObject, [
         'thinkingConfig',
@@ -8968,6 +11016,12 @@ function liveConnectConfigToVertex(fromObject, parentObject) {
     if (parentObject !== undefined && fromProactivity != null) {
         setValueByPath(parentObject, ['setup', 'proactivity'], fromProactivity);
     }
+    const fromExplicitVadSignal = getValueByPath(fromObject, [
+        'explicitVadSignal',
+    ]);
+    if (parentObject !== undefined && fromExplicitVadSignal != null) {
+        setValueByPath(parentObject, ['setup', 'explicitVadSignal'], fromExplicitVadSignal);
+    }
     return toObject;
 }
 function liveConnectParametersToMldev(apiClient, fromObject) {
@@ -9144,6 +11198,12 @@ function liveServerMessageFromVertex(fromObject) {
     if (fromSessionResumptionUpdate != null) {
         setValueByPath(toObject, ['sessionResumptionUpdate'], fromSessionResumptionUpdate);
     }
+    const fromVoiceActivityDetectionSignal = getValueByPath(fromObject, [
+        'voiceActivityDetectionSignal',
+    ]);
+    if (fromVoiceActivityDetectionSignal != null) {
+        setValueByPath(toObject, ['voiceActivityDetectionSignal'], fromVoiceActivityDetectionSignal);
+    }
     return toObject;
 }
 function partToMldev$2(fromObject) {
@@ -9217,21 +11277,6 @@ function sessionResumptionConfigToMldev$1(fromObject) {
     }
     return toObject;
 }
-function speechConfigToVertex$1(fromObject) {
-    const toObject = {};
-    const fromVoiceConfig = getValueByPath(fromObject, ['voiceConfig']);
-    if (fromVoiceConfig != null) {
-        setValueByPath(toObject, ['voiceConfig'], fromVoiceConfig);
-    }
-    const fromLanguageCode = getValueByPath(fromObject, ['languageCode']);
-    if (fromLanguageCode != null) {
-        setValueByPath(toObject, ['languageCode'], fromLanguageCode);
-    }
-    if (getValueByPath(fromObject, ['multiSpeakerVoiceConfig']) !== undefined) {
-        throw new Error('multiSpeakerVoiceConfig parameter is not supported in Vertex AI.');
-    }
-    return toObject;
-}
 function toolToMldev$2(fromObject) {
     const toObject = {};
     const fromFunctionDeclarations = getValueByPath(fromObject, [
@@ -10474,7 +12519,7 @@ function generateContentConfigToVertex(apiClient, fromObject, parentObject) {
     }
     const fromSpeechConfig = getValueByPath(fromObject, ['speechConfig']);
     if (fromSpeechConfig != null) {
-        setValueByPath(toObject, ['speechConfig'], speechConfigToVertex(tSpeechConfig(fromSpeechConfig)));
+        setValueByPath(toObject, ['speechConfig'], tSpeechConfig(fromSpeechConfig));
     }
     const fromAudioTimestamp = getValueByPath(fromObject, [
         'audioTimestamp',
@@ -11420,7 +13465,7 @@ function generationConfigToVertex(fromObject) {
     }
     const fromSpeechConfig = getValueByPath(fromObject, ['speechConfig']);
     if (fromSpeechConfig != null) {
-        setValueByPath(toObject, ['speechConfig'], speechConfigToVertex(fromSpeechConfig));
+        setValueByPath(toObject, ['speechConfig'], fromSpeechConfig);
     }
     const fromStopSequences = getValueByPath(fromObject, [
         'stopSequences',
@@ -12222,21 +14267,6 @@ function segmentImageSourceToVertex(fromObject, parentObject) {
     }
     return toObject;
 }
-function speechConfigToVertex(fromObject) {
-    const toObject = {};
-    const fromVoiceConfig = getValueByPath(fromObject, ['voiceConfig']);
-    if (fromVoiceConfig != null) {
-        setValueByPath(toObject, ['voiceConfig'], fromVoiceConfig);
-    }
-    const fromLanguageCode = getValueByPath(fromObject, ['languageCode']);
-    if (fromLanguageCode != null) {
-        setValueByPath(toObject, ['languageCode'], fromLanguageCode);
-    }
-    if (getValueByPath(fromObject, ['multiSpeakerVoiceConfig']) !== undefined) {
-        throw new Error('multiSpeakerVoiceConfig parameter is not supported in Vertex AI.');
-    }
-    return toObject;
-}
 function toolConfigToMldev(fromObject) {
     const toObject = {};
     const fromFunctionCallingConfig = getValueByPath(fromObject, [
@@ -15526,6 +17556,9 @@ function liveConnectConfigToMldev(fromObject, parentObject) {
     if (parentObject !== undefined && fromProactivity != null) {
         setValueByPath(parentObject, ['setup', 'proactivity'], fromProactivity);
     }
+    if (getValueByPath(fromObject, ['explicitVadSignal']) !== undefined) {
+        throw new Error('explicitVadSignal parameter is not supported in Gemini API.');
+    }
     return toObject;
 }
 function liveConnectConstraintsToMldev(apiClient, fromObject) {
@@ -17069,6 +19102,30 @@ const LANGUAGE_LABEL_PREFIX = 'gl-node/';
  *
  */
 class GoogleGenAI {
+    get interactions() {
+        if (this._interactions !== undefined) {
+            return this._interactions;
+        }
+        console.warn('GoogleGenAI.interactions: Interactions usage is experimental and may change in future versions.');
+        if (this.vertexai) {
+            throw new Error('This version of the GenAI SDK does not support Vertex AI API for interactions.');
+        }
+        const httpOpts = this.httpOptions;
+        // Unsupported Options Warnings
+        if (httpOpts === null || httpOpts === void 0 ? void 0 : httpOpts.extraBody) {
+            console.warn('GoogleGenAI.interactions: Client level httpOptions.extraBody is not supported by the interactions client and will be ignored.');
+        }
+        const nextGenClient = new GeminiNextGenAPIClient({
+            baseURL: this.apiClient.getBaseUrl(),
+            apiKey: this.apiKey,
+            apiVersion: this.apiClient.getApiVersion(),
+            clientAdapter: this.apiClient,
+            defaultHeaders: this.apiClient.getDefaultHeaders(),
+            timeout: httpOpts === null || httpOpts === void 0 ? void 0 : httpOpts.timeout,
+        });
+        this._interactions = nextGenClient.interactions;
+        return this._interactions;
+    }
     constructor(options) {
         var _a;
         if (options.apiKey == null) {