@firebase/ai 2.6.1 → 2.7.0-20260114192924

package/dist/index.node.cjs.js

@@ -8,7 +8,7 @@ var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 
 var name = "@firebase/ai";
-var version = "2.6.1";
+var version = "2.7.0-20260114192924";
 
 /**
  * @license
@@ -36,7 +36,7 @@ const DEFAULT_FETCH_TIMEOUT_MS = 180 * 1000;
 /**
  * Defines the name of the default in-cloud model to use for hybrid inference.
  */
-const DEFAULT_HYBRID_IN_CLOUD_MODEL = 'gemini-2.0-flash-lite';
+const DEFAULT_HYBRID_IN_CLOUD_MODEL = 'gemini-2.5-flash-lite';
 
 /**
  * @license
@@ -412,6 +412,19 @@ const Language = {
     UNSPECIFIED: 'LANGUAGE_UNSPECIFIED',
     PYTHON: 'PYTHON'
 };
+/**
+ * A preset that controls the model's "thinking" process. Use
+ * `ThinkingLevel.LOW` for faster responses on less complex tasks, and
+ * `ThinkingLevel.HIGH` for better reasoning on more complex tasks.
+ *
+ * @public
+ */
+const ThinkingLevel = {
+    MINIMAL: 'MINIMAL',
+    LOW: 'LOW',
+    MEDIUM: 'MEDIUM',
+    HIGH: 'HIGH'
+};
 
 /**
  * @license
@@ -1137,6 +1150,8 @@ const logger = new logger$1.Logger('@firebase/vertexai');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const TIMEOUT_EXPIRED_MESSAGE = 'Timeout has expired.';
+const ABORT_ERROR_NAME = 'AbortError';
 class RequestURL {
     constructor(params) {
         this.params = params;
@@ -1159,7 +1174,7 @@ class RequestURL {
         }
     }
     get baseUrl() {
-        return this.params.requestOptions?.baseUrl ?? `https://${DEFAULT_DOMAIN}`;
+        return (this.params.singleRequestOptions?.baseUrl ?? `https://${DEFAULT_DOMAIN}`);
     }
     get queryParams() {
         const params = new URLSearchParams();
@@ -1227,21 +1242,32 @@ async function getHeaders(url) {
 async function makeRequest(requestUrlParams, body) {
     const url = new RequestURL(requestUrlParams);
     let response;
-    let fetchTimeoutId;
+    const externalSignal = requestUrlParams.singleRequestOptions?.signal;
+    const timeoutMillis = requestUrlParams.singleRequestOptions?.timeout != null &&
+        requestUrlParams.singleRequestOptions.timeout >= 0
+        ? requestUrlParams.singleRequestOptions.timeout
+        : DEFAULT_FETCH_TIMEOUT_MS;
+    const internalAbortController = new AbortController();
+    const fetchTimeoutId = setTimeout(() => {
+        internalAbortController.abort(new DOMException(TIMEOUT_EXPIRED_MESSAGE, ABORT_ERROR_NAME));
+        logger.debug(`Aborting request to ${url} due to timeout (${timeoutMillis}ms)`);
+    }, timeoutMillis);
+    // Used to abort the fetch if either the user-defined `externalSignal` is aborted, or if the
+    // internal signal (triggered by timeouts) is aborted.
+    const combinedSignal = AbortSignal.any(externalSignal
+        ? [externalSignal, internalAbortController.signal]
+        : [internalAbortController.signal]);
+    if (externalSignal && externalSignal.aborted) {
+        clearTimeout(fetchTimeoutId);
+        throw new DOMException(externalSignal.reason ?? 'Aborted externally before fetch', ABORT_ERROR_NAME);
+    }
     try {
         const fetchOptions = {
             method: 'POST',
             headers: await getHeaders(url),
+            signal: combinedSignal,
             body
         };
-        // Timeout is 180s by default.
-        const timeoutMillis = requestUrlParams.requestOptions?.timeout != null &&
-            requestUrlParams.requestOptions.timeout >= 0
-            ? requestUrlParams.requestOptions.timeout
-            : DEFAULT_FETCH_TIMEOUT_MS;
-        const abortController = new AbortController();
-        fetchTimeoutId = setTimeout(() => abortController.abort(), timeoutMillis);
-        fetchOptions.signal = abortController.signal;
         response = await fetch(url.toString(), fetchOptions);
         if (!response.ok) {
             let message = '';
@@ -1284,16 +1310,18 @@ async function makeRequest(requestUrlParams, body) {
         let err = e;
         if (e.code !== AIErrorCode.FETCH_ERROR &&
             e.code !== AIErrorCode.API_NOT_ENABLED &&
-            e instanceof Error) {
+            e instanceof Error &&
+            e.name !== ABORT_ERROR_NAME) {
             err = new AIError(AIErrorCode.ERROR, `Error fetching from ${url.toString()}: ${e.message}`);
             err.stack = e.stack;
         }
         throw err;
     }
     finally {
-        if (fetchTimeoutId) {
-            clearTimeout(fetchTimeoutId);
-        }
+        // When doing streaming requests, this will clear the timeout once the stream begins.
+        // If a timeout it 3000ms, and the stream starts after 300ms and ends after 5000ms, the
+        // timeout will be cleared after 300ms, so it won't abort the request.
+        clearTimeout(fetchTimeoutId);
     }
     return response;
 }
@@ -1731,6 +1759,8 @@ const responseLineRE = /^data\: (.*)(?:\n\n|\r\r|\r\n\r\n)/;
 function processStream(response, apiSettings, inferenceSource) {
     const inputStream = response.body.pipeThrough(new TextDecoderStream('utf8', { fatal: true }));
     const responseStream = getResponseStream(inputStream);
+    // We split the stream so the user can iterate over partial results (stream1)
+    // while we aggregate the full result for history/final response (stream2).
     const [stream1, stream2] = responseStream.tee();
     return {
         stream: generateResponseSequence(stream1, apiSettings, inferenceSource),
@@ -1767,7 +1797,6 @@ async function* generateResponseSequence(stream, apiSettings, inferenceSource) {
             enhancedResponse = createEnhancedContentResponse(value, inferenceSource);
         }
         const firstCandidate = enhancedResponse.candidates?.[0];
-        // Don't yield a response with no useful data for the developer.
         if (!firstCandidate?.content?.parts &&
             !firstCandidate?.finishReason &&
             !firstCandidate?.citationMetadata &&
@@ -1778,9 +1807,7 @@ async function* generateResponseSequence(stream, apiSettings, inferenceSource) {
     }
 }
 /**
- * Reads a raw stream from the fetch response and join incomplete
- * chunks, returning a new stream that provides a single complete
- * GenerateContentResponse in each iteration.
+ * Reads a raw string stream, buffers incomplete chunks, and yields parsed JSON objects.
  */
 function getResponseStream(inputStream) {
     const reader = inputStream.getReader();
@@ -1799,6 +1826,8 @@ function getResponseStream(inputStream) {
                         return;
                     }
                     currentText += value;
+                    // SSE events may span chunk boundaries, so we buffer until we match
+                    // the full "data: {json}\n\n" pattern.
                     let match = currentText.match(responseLineRE);
                     let parsedResponse;
                     while (match) {
@@ -1832,8 +1861,7 @@ function aggregateResponses(responses) {
     for (const response of responses) {
         if (response.candidates) {
             for (const candidate of response.candidates) {
-                // Index will be undefined if it's the first index (0), so we should use 0 if it's undefined.
-                // See: https://github.com/firebase/firebase-js-sdk/issues/8566
+                // Use 0 if index is undefined (protobuf default value omission).
                 const i = candidate.index || 0;
                 if (!aggregatedResponse.candidates) {
                     aggregatedResponse.candidates = [];
@@ -1843,7 +1871,7 @@ function aggregateResponses(responses) {
                         index: candidate.index
                     };
                 }
-                // Keep overwriting, the last one will be final
+                // Overwrite with the latest metadata
                 aggregatedResponse.candidates[i].citationMetadata =
                     candidate.citationMetadata;
                 aggregatedResponse.candidates[i].finishReason = candidate.finishReason;
@@ -1864,12 +1892,7 @@ function aggregateResponses(responses) {
                     aggregatedResponse.candidates[i].urlContextMetadata =
                         urlContextMetadata;
                 }
-                /**
-                 * Candidates should always have content and parts, but this handles
-                 * possible malformed responses.
-                 */
                 if (candidate.content) {
-                    // Skip a candidate without parts.
                     if (!candidate.content.parts) {
                         continue;
                     }
@@ -2001,7 +2024,7 @@ async function callCloudOrDevice(request, chromeAdapter, onDeviceCall, inCloudCa
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-async function generateContentStreamOnCloud(apiSettings, model, params, requestOptions) {
+async function generateContentStreamOnCloud(apiSettings, model, params, singleRequestOptions) {
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
@@ -2010,14 +2033,14 @@ async function generateContentStreamOnCloud(apiSettings, model, params, requestO
         model,
         apiSettings,
         stream: true,
-        requestOptions
+        singleRequestOptions
     }, JSON.stringify(params));
 }
-async function generateContentStream(apiSettings, model, params, chromeAdapter, requestOptions) {
-    const callResult = await callCloudOrDevice(params, chromeAdapter, () => chromeAdapter.generateContentStream(params), () => generateContentStreamOnCloud(apiSettings, model, params, requestOptions));
+async function generateContentStream(apiSettings, model, params, chromeAdapter, singleRequestOptions) {
+    const callResult = await callCloudOrDevice(params, chromeAdapter, () => chromeAdapter.generateContentStream(params), () => generateContentStreamOnCloud(apiSettings, model, params, singleRequestOptions));
     return processStream(callResult.response, apiSettings, callResult.inferenceSource);
 }
-async function generateContentOnCloud(apiSettings, model, params, requestOptions) {
+async function generateContentOnCloud(apiSettings, model, params, singleRequestOptions) {
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
@@ -2026,16 +2049,16 @@ async function generateContentOnCloud(apiSettings, model, params, requestOptions
         task: "generateContent" /* Task.GENERATE_CONTENT */,
         apiSettings,
         stream: false,
-        requestOptions
+        singleRequestOptions
     }, JSON.stringify(params));
 }
-async function templateGenerateContent(apiSettings, templateId, templateParams, requestOptions) {
+async function templateGenerateContent(apiSettings, templateId, templateParams, singleRequestOptions) {
     const response = await makeRequest({
         task: "templateGenerateContent" /* ServerPromptTemplateTask.TEMPLATE_GENERATE_CONTENT */,
         templateId,
         apiSettings,
         stream: false,
-        requestOptions
+        singleRequestOptions
     }, JSON.stringify(templateParams));
     const generateContentResponse = await processGenerateContentResponse(response, apiSettings);
     const enhancedResponse = createEnhancedContentResponse(generateContentResponse);
@@ -2043,18 +2066,18 @@ async function templateGenerateContent(apiSettings, templateId, templateParams,
         response: enhancedResponse
     };
 }
-async function templateGenerateContentStream(apiSettings, templateId, templateParams, requestOptions) {
+async function templateGenerateContentStream(apiSettings, templateId, templateParams, singleRequestOptions) {
     const response = await makeRequest({
         task: "templateStreamGenerateContent" /* ServerPromptTemplateTask.TEMPLATE_STREAM_GENERATE_CONTENT */,
         templateId,
         apiSettings,
         stream: true,
-        requestOptions
+        singleRequestOptions
     }, JSON.stringify(templateParams));
     return processStream(response, apiSettings);
 }
-async function generateContent(apiSettings, model, params, chromeAdapter, requestOptions) {
-    const callResult = await callCloudOrDevice(params, chromeAdapter, () => chromeAdapter.generateContent(params), () => generateContentOnCloud(apiSettings, model, params, requestOptions));
+async function generateContent(apiSettings, model, params, chromeAdapter, singleRequestOptions) {
+    const callResult = await callCloudOrDevice(params, chromeAdapter, () => chromeAdapter.generateContent(params), () => generateContentOnCloud(apiSettings, model, params, singleRequestOptions));
     const generateContentResponse = await processGenerateContentResponse(callResult.response, apiSettings);
     const enhancedResponse = createEnhancedContentResponse(generateContentResponse, callResult.inferenceSource);
     return {
@@ -2308,7 +2331,8 @@ function validateChatHistory(history) {
  * limitations under the License.
  */
 /**
- * Do not log a message for this error.
+ * Used to break the internal promise chain when an error is already handled
+ * by the user, preventing duplicate console logs.
  */
 const SILENT_ERROR = 'SILENT_ERROR';
 /**
@@ -2324,6 +2348,10 @@ class ChatSession {
         this.params = params;
         this.requestOptions = requestOptions;
         this._history = [];
+        /**
+         * Ensures sequential execution of chat messages to maintain history order.
+         * Each call waits for the previous one to settle before proceeding.
+         */
         this._sendPromise = Promise.resolve();
         this._apiSettings = apiSettings;
         if (params?.history) {
@@ -2344,7 +2372,7 @@ class ChatSession {
      * Sends a chat message and receives a non-streaming
      * {@link GenerateContentResult}
      */
-    async sendMessage(request) {
+    async sendMessage(request, singleRequestOptions) {
         await this._sendPromise;
         const newContent = formatNewContent(request);
         const generateContentRequest = {
@@ -2356,16 +2384,20 @@ class ChatSession {
             contents: [...this._history, newContent]
         };
         let finalResult = {};
-        // Add onto the chain.
         this._sendPromise = this._sendPromise
-            .then(() => generateContent(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, this.requestOptions))
+            .then(() => generateContent(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        }))
             .then(result => {
+            // TODO: Make this update atomic. If creating `responseContent` throws,
+            // history will contain the user message but not the response, causing
+            // validation errors on the next request.
             if (result.response.candidates &&
                 result.response.candidates.length > 0) {
                 this._history.push(newContent);
                 const responseContent = {
                     parts: result.response.candidates?.[0].content.parts || [],
-                    // Response seems to come back without a role set.
                     role: result.response.candidates?.[0].content.role || 'model'
                 };
                 this._history.push(responseContent);
@@ -2386,7 +2418,7 @@ class ChatSession {
      * {@link GenerateContentStreamResult} containing an iterable stream
      * and a response promise.
      */
-    async sendMessageStream(request) {
+    async sendMessageStream(request, singleRequestOptions) {
         await this._sendPromise;
         const newContent = formatNewContent(request);
         const generateContentRequest = {
@@ -2397,21 +2429,29 @@ class ChatSession {
             systemInstruction: this.params?.systemInstruction,
             contents: [...this._history, newContent]
         };
-        const streamPromise = generateContentStream(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, this.requestOptions);
-        // Add onto the chain.
+        const streamPromise = generateContentStream(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
+        // We hook into the chain to update history, but we don't block the
+        // return of `streamPromise` to the user.
         this._sendPromise = this._sendPromise
             .then(() => streamPromise)
-            // This must be handled to avoid unhandled rejection, but jump
-            // to the final catch block with a label to not log this error.
             .catch(_ignored => {
+            // If the initial fetch fails, the user's `streamPromise` rejects.
+            // We swallow the error here to prevent double logging in the final catch.
             throw new Error(SILENT_ERROR);
         })
             .then(streamResult => streamResult.response)
             .then(response => {
+            // This runs after the stream completes. Runtime errors here cannot be
+            // caught by the user because their promise has likely already resolved.
+            // TODO: Move response validation logic upstream to `stream-reader` so
+            // errors propagate to the user's `result.response` promise.
             if (response.candidates && response.candidates.length > 0) {
                 this._history.push(newContent);
+                // TODO: Validate that `response.candidates[0].content` is not null.
                 const responseContent = { ...response.candidates[0].content };
-                // Response seems to come back without a role set.
                 if (!responseContent.role) {
                     responseContent.role = 'model';
                 }
@@ -2425,12 +2465,8 @@ class ChatSession {
             }
         })
             .catch(e => {
-            // Errors in streamPromise are already catchable by the user as
-            // streamPromise is returned.
-            // Avoid duplicating the error message in logs.
-            if (e.message !== SILENT_ERROR) {
-                // Users do not have access to _sendPromise to catch errors
-                // downstream from streamPromise, so they should not throw.
+            // Filter out errors already handled by the user or initiated by them.
+            if (e.message !== SILENT_ERROR && e.name !== 'AbortError') {
                 logger.error(e);
             }
         });
@@ -2454,7 +2490,7 @@ class ChatSession {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-async function countTokensOnCloud(apiSettings, model, params, requestOptions) {
+async function countTokensOnCloud(apiSettings, model, params, singleRequestOptions) {
     let body = '';
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         const mappedParams = mapCountTokensRequest(params, model);
@@ -2468,7 +2504,7 @@ async function countTokensOnCloud(apiSettings, model, params, requestOptions) {
         task: "countTokens" /* Task.COUNT_TOKENS */,
         apiSettings,
         stream: false,
-        requestOptions
+        singleRequestOptions
     }, body);
     return response.json();
 }
@@ -2504,6 +2540,7 @@ class GenerativeModel extends AIModel {
         super(ai, modelParams.model);
         this.chromeAdapter = chromeAdapter;
         this.generationConfig = modelParams.generationConfig || {};
+        validateGenerationConfig(this.generationConfig);
         this.safetySettings = modelParams.safetySettings || [];
         this.tools = modelParams.tools;
         this.toolConfig = modelParams.toolConfig;
@@ -2514,7 +2551,7 @@ class GenerativeModel extends AIModel {
      * Makes a single non-streaming call to the model
      * and returns an object containing a single {@link GenerateContentResponse}.
      */
-    async generateContent(request) {
+    async generateContent(request, singleRequestOptions) {
         const formattedParams = formatGenerateContentInput(request);
         return generateContent(this._apiSettings, this.model, {
             generationConfig: this.generationConfig,
@@ -2523,7 +2560,12 @@ class GenerativeModel extends AIModel {
             toolConfig: this.toolConfig,
             systemInstruction: this.systemInstruction,
             ...formattedParams
-        }, this.chromeAdapter, this.requestOptions);
+        }, this.chromeAdapter, 
+        // Merge request options
+        {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
     }
     /**
      * Makes a single streaming call to the model
@@ -2531,7 +2573,7 @@ class GenerativeModel extends AIModel {
      * over all chunks in the streaming response as well as
      * a promise that returns the final aggregated response.
      */
-    async generateContentStream(request) {
+    async generateContentStream(request, singleRequestOptions) {
         const formattedParams = formatGenerateContentInput(request);
         return generateContentStream(this._apiSettings, this.model, {
             generationConfig: this.generationConfig,
@@ -2540,7 +2582,12 @@ class GenerativeModel extends AIModel {
             toolConfig: this.toolConfig,
             systemInstruction: this.systemInstruction,
             ...formattedParams
-        }, this.chromeAdapter, this.requestOptions);
+        }, this.chromeAdapter, 
+        // Merge request options
+        {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
     }
     /**
      * Gets a new {@link ChatSession} instance which can be used for
@@ -2564,9 +2611,26 @@ class GenerativeModel extends AIModel {
     /**
      * Counts the tokens in the provided request.
      */
-    async countTokens(request) {
+    async countTokens(request, singleRequestOptions) {
         const formattedParams = formatGenerateContentInput(request);
-        return countTokens(this._apiSettings, this.model, formattedParams, this.chromeAdapter);
+        return countTokens(this._apiSettings, this.model, formattedParams, this.chromeAdapter, 
+        // Merge request options
+        {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
+    }
+}
+/**
+ * Client-side validation of some common `GenerationConfig` pitfalls, in order
+ * to save the developer a wasted request.
+ */
+function validateGenerationConfig(generationConfig) {
+    if (
+    // != allows for null and undefined. 0 is considered "set" by the model
+    generationConfig.thinkingConfig?.thinkingBudget != null &&
+        generationConfig.thinkingConfig?.thinkingLevel) {
+        throw new AIError(AIErrorCode.UNSUPPORTED, `Cannot set both thinkingBudget and thinkingLevel in a config.`);
     }
 }
 
@@ -3017,7 +3081,7 @@ class ImagenModel extends AIModel {
      *
      * @public
      */
-    async generateImages(prompt) {
+    async generateImages(prompt, singleRequestOptions) {
         const body = createPredictRequestBody(prompt, {
             ...this.generationConfig,
             ...this.safetySettings
@@ -3027,7 +3091,11 @@ class ImagenModel extends AIModel {
             model: this.model,
             apiSettings: this._apiSettings,
             stream: false,
-            requestOptions: this.requestOptions
+            // Merge request options. Single request options overwrite the model's request options.
+            singleRequestOptions: {
+                ...this.requestOptions,
+                ...singleRequestOptions
+            }
         }, JSON.stringify(body));
         return handlePredictResponse(response);
     }
@@ -3050,7 +3118,7 @@ class ImagenModel extends AIModel {
      * returned object will have a `filteredReason` property.
      * If all images are filtered, the `images` array will be empty.
      */
-    async generateImagesGCS(prompt, gcsURI) {
+    async generateImagesGCS(prompt, gcsURI, singleRequestOptions) {
         const body = createPredictRequestBody(prompt, {
             gcsURI,
             ...this.generationConfig,
@@ -3061,7 +3129,11 @@ class ImagenModel extends AIModel {
             model: this.model,
             apiSettings: this._apiSettings,
             stream: false,
-            requestOptions: this.requestOptions
+            // Merge request options. Single request options overwrite the model's request options.
+            singleRequestOptions: {
+                ...this.requestOptions,
+                ...singleRequestOptions
+            }
         }, JSON.stringify(body));
         return handlePredictResponse(response);
     }
@@ -3255,9 +3327,11 @@ class TemplateGenerativeModel {
      *
      * @beta
      */
-    async generateContent(templateId, templateVariables // anything!
-    ) {
-        return templateGenerateContent(this._apiSettings, templateId, { inputs: templateVariables }, this.requestOptions);
+    async generateContent(templateId, templateVariables, singleRequestOptions) {
+        return templateGenerateContent(this._apiSettings, templateId, { inputs: templateVariables }, {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
     }
     /**
      * Makes a single streaming call to the model and returns an object
@@ -3271,8 +3345,11 @@ class TemplateGenerativeModel {
      *
      * @beta
      */
-    async generateContentStream(templateId, templateVariables) {
-        return templateGenerateContentStream(this._apiSettings, templateId, { inputs: templateVariables }, this.requestOptions);
+    async generateContentStream(templateId, templateVariables, singleRequestOptions) {
+        return templateGenerateContentStream(this._apiSettings, templateId, { inputs: templateVariables }, {
+            ...this.requestOptions,
+            ...singleRequestOptions
+        });
     }
 }
 
@@ -3317,13 +3394,16 @@ class TemplateImagenModel {
      *
      * @beta
      */
-    async generateImages(templateId, templateVariables) {
+    async generateImages(templateId, templateVariables, singleRequestOptions) {
         const response = await makeRequest({
             task: "templatePredict" /* ServerPromptTemplateTask.TEMPLATE_PREDICT */,
             templateId,
             apiSettings: this._apiSettings,
             stream: false,
-            requestOptions: this.requestOptions
+            singleRequestOptions: {
+                ...this.requestOptions,
+                ...singleRequestOptions
+            }
         }, JSON.stringify({ inputs: templateVariables }));
         return handlePredictResponse(response);
     }
@@ -4200,6 +4280,7 @@ exports.SchemaType = SchemaType;
 exports.StringSchema = StringSchema;
 exports.TemplateGenerativeModel = TemplateGenerativeModel;
 exports.TemplateImagenModel = TemplateImagenModel;
+exports.ThinkingLevel = ThinkingLevel;
 exports.URLRetrievalStatus = URLRetrievalStatus;
 exports.VertexAIBackend = VertexAIBackend;
 exports.getAI = getAI;