@firebase/ai 2.5.0-canary.0800a8bed → 2.5.0-canary.5c35f514c

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.5.0-canary.0800a8bed";
+var version = "2.5.0-canary.5c35f514c";
 
 /**
  * @license
@@ -770,6 +770,18 @@ class GoogleAIBackend extends Backend {
     constructor() {
         super(BackendType.GOOGLE_AI);
     }
+    /**
+     * @internal
+     */
+    _getModelPath(project, model) {
+        return `/${DEFAULT_API_VERSION}/projects/${project}/${model}`;
+    }
+    /**
+     * @internal
+     */
+    _getTemplatePath(project, templateId) {
+        return `/${DEFAULT_API_VERSION}/projects/${project}/templates/${templateId}`;
+    }
 }
 /**
  * Configuration class for the Vertex AI Gemini API.
@@ -796,6 +808,18 @@ class VertexAIBackend extends Backend {
             this.location = location;
         }
     }
+    /**
+     * @internal
+     */
+    _getModelPath(project, model) {
+        return `/${DEFAULT_API_VERSION}/projects/${project}/locations/${this.location}/${model}`;
+    }
+    /**
+     * @internal
+     */
+    _getTemplatePath(project, templateId) {
+        return `/${DEFAULT_API_VERSION}/projects/${project}/locations/${this.location}/templates/${templateId}`;
+    }
 }
 
 /**
@@ -927,6 +951,67 @@ function factory(container, { instanceIdentifier }) {
     return new AIService(app, backend, auth, appCheckProvider);
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Initializes an {@link ApiSettings} object from an {@link AI} instance.
+ *
+ * If this is a Server App, the {@link ApiSettings} object's `getAppCheckToken()` will resolve
+ * with the `FirebaseServerAppSettings.appCheckToken`, instead of requiring that an App Check
+ * instance is initialized.
+ */
+function initApiSettings(ai) {
+    if (!ai.app?.options?.apiKey) {
+        throw new AIError(AIErrorCode.NO_API_KEY, `The "apiKey" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid API key.`);
+    }
+    else if (!ai.app?.options?.projectId) {
+        throw new AIError(AIErrorCode.NO_PROJECT_ID, `The "projectId" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid project ID.`);
+    }
+    else if (!ai.app?.options?.appId) {
+        throw new AIError(AIErrorCode.NO_APP_ID, `The "appId" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid app ID.`);
+    }
+    const apiSettings = {
+        apiKey: ai.app.options.apiKey,
+        project: ai.app.options.projectId,
+        appId: ai.app.options.appId,
+        automaticDataCollectionEnabled: ai.app.automaticDataCollectionEnabled,
+        location: ai.location,
+        backend: ai.backend
+    };
+    if (app._isFirebaseServerApp(ai.app) && ai.app.settings.appCheckToken) {
+        const token = ai.app.settings.appCheckToken;
+        apiSettings.getAppCheckToken = () => {
+            return Promise.resolve({ token });
+        };
+    }
+    else if (ai.appCheck) {
+        if (ai.options?.useLimitedUseAppCheckTokens) {
+            apiSettings.getAppCheckToken = () => ai.appCheck.getLimitedUseToken();
+        }
+        else {
+            apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
+        }
+    }
+    if (ai.auth) {
+        apiSettings.getAuthToken = () => ai.auth.getToken();
+    }
+    return apiSettings;
+}
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -970,43 +1055,8 @@ class AIModel {
      * @internal
      */
     constructor(ai, modelName) {
-        if (!ai.app?.options?.apiKey) {
-            throw new AIError(AIErrorCode.NO_API_KEY, `The "apiKey" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid API key.`);
-        }
-        else if (!ai.app?.options?.projectId) {
-            throw new AIError(AIErrorCode.NO_PROJECT_ID, `The "projectId" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid project ID.`);
-        }
-        else if (!ai.app?.options?.appId) {
-            throw new AIError(AIErrorCode.NO_APP_ID, `The "appId" field is empty in the local Firebase config. Firebase AI requires this field to contain a valid app ID.`);
-        }
-        else {
-            this._apiSettings = {
-                apiKey: ai.app.options.apiKey,
-                project: ai.app.options.projectId,
-                appId: ai.app.options.appId,
-                automaticDataCollectionEnabled: ai.app.automaticDataCollectionEnabled,
-                location: ai.location,
-                backend: ai.backend
-            };
-            if (app._isFirebaseServerApp(ai.app) && ai.app.settings.appCheckToken) {
-                const token = ai.app.settings.appCheckToken;
-                this._apiSettings.getAppCheckToken = () => {
-                    return Promise.resolve({ token });
-                };
-            }
-            else if (ai.appCheck) {
-                if (ai.options?.useLimitedUseAppCheckTokens) {
-                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getLimitedUseToken();
-                }
-                else {
-                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
-                }
-            }
-            if (ai.auth) {
-                this._apiSettings.getAuthToken = () => ai.auth.getToken();
-            }
-            this.model = AIModel.normalizeModelName(modelName, this._apiSettings.backend.backendType);
-        }
+        this._apiSettings = initApiSettings(ai);
+        this.model = AIModel.normalizeModelName(modelName, this._apiSettings.backend.backendType);
     }
     /**
      * Normalizes the given model name to a fully qualified model resource name.
@@ -1073,7 +1123,7 @@ const logger = new logger$1.Logger('@firebase/vertexai');
 
 /**
  * @license
- * Copyright 2024 Google LLC
+ * Copyright 2025 Google LLC
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -1087,47 +1137,33 @@ const logger = new logger$1.Logger('@firebase/vertexai');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var Task;
-(function (Task) {
-    Task["GENERATE_CONTENT"] = "generateContent";
-    Task["STREAM_GENERATE_CONTENT"] = "streamGenerateContent";
-    Task["COUNT_TOKENS"] = "countTokens";
-    Task["PREDICT"] = "predict";
-})(Task || (Task = {}));
-class RequestUrl {
-    constructor(model, task, apiSettings, stream, requestOptions) {
-        this.model = model;
-        this.task = task;
-        this.apiSettings = apiSettings;
-        this.stream = stream;
-        this.requestOptions = requestOptions;
+class RequestURL {
+    constructor(params) {
+        this.params = params;
     }
     toString() {
         const url = new URL(this.baseUrl); // Throws if the URL is invalid
-        url.pathname = `/${this.apiVersion}/${this.modelPath}:${this.task}`;
+        url.pathname = this.pathname;
         url.search = this.queryParams.toString();
         return url.toString();
     }
-    get baseUrl() {
-        return this.requestOptions?.baseUrl || `https://${DEFAULT_DOMAIN}`;
-    }
-    get apiVersion() {
-        return DEFAULT_API_VERSION; // TODO: allow user-set options if that feature becomes available
-    }
-    get modelPath() {
-        if (this.apiSettings.backend instanceof GoogleAIBackend) {
-            return `projects/${this.apiSettings.project}/${this.model}`;
-        }
-        else if (this.apiSettings.backend instanceof VertexAIBackend) {
-            return `projects/${this.apiSettings.project}/locations/${this.apiSettings.backend.location}/${this.model}`;
+    get pathname() {
+        // We need to construct a different URL if the request is for server side prompt templates,
+        // since the URL patterns are different. Server side prompt templates expect a templateId
+        // instead of a model name.
+        if (this.params.templateId) {
+            return `${this.params.apiSettings.backend._getTemplatePath(this.params.apiSettings.project, this.params.templateId)}:${this.params.task}`;
         }
         else {
-            throw new AIError(AIErrorCode.ERROR, `Invalid backend: ${JSON.stringify(this.apiSettings.backend)}`);
+            return `${this.params.apiSettings.backend._getModelPath(this.params.apiSettings.project, this.params.model)}:${this.params.task}`;
         }
     }
+    get baseUrl() {
+        return this.params.requestOptions?.baseUrl ?? `https://${DEFAULT_DOMAIN}`;
+    }
     get queryParams() {
         const params = new URLSearchParams();
-        if (this.stream) {
+        if (this.params.stream) {
             params.set('alt', 'sse');
         }
         return params;
@@ -1167,12 +1203,12 @@ async function getHeaders(url) {
     const headers = new Headers();
     headers.append('Content-Type', 'application/json');
     headers.append('x-goog-api-client', getClientHeaders());
-    headers.append('x-goog-api-key', url.apiSettings.apiKey);
-    if (url.apiSettings.automaticDataCollectionEnabled) {
-        headers.append('X-Firebase-Appid', url.apiSettings.appId);
+    headers.append('x-goog-api-key', url.params.apiSettings.apiKey);
+    if (url.params.apiSettings.automaticDataCollectionEnabled) {
+        headers.append('X-Firebase-Appid', url.params.apiSettings.appId);
     }
-    if (url.apiSettings.getAppCheckToken) {
-        const appCheckToken = await url.apiSettings.getAppCheckToken();
+    if (url.params.apiSettings.getAppCheckToken) {
+        const appCheckToken = await url.params.apiSettings.getAppCheckToken();
         if (appCheckToken) {
             headers.append('X-Firebase-AppCheck', appCheckToken.token);
             if (appCheckToken.error) {
@@ -1180,39 +1216,33 @@ async function getHeaders(url) {
             }
         }
     }
-    if (url.apiSettings.getAuthToken) {
-        const authToken = await url.apiSettings.getAuthToken();
+    if (url.params.apiSettings.getAuthToken) {
+        const authToken = await url.params.apiSettings.getAuthToken();
         if (authToken) {
             headers.append('Authorization', `Firebase ${authToken.accessToken}`);
         }
     }
     return headers;
 }
-async function constructRequest(model, task, apiSettings, stream, body, requestOptions) {
-    const url = new RequestUrl(model, task, apiSettings, stream, requestOptions);
-    return {
-        url: url.toString(),
-        fetchOptions: {
-            method: 'POST',
-            headers: await getHeaders(url),
-            body
-        }
-    };
-}
-async function makeRequest(model, task, apiSettings, stream, body, requestOptions) {
-    const url = new RequestUrl(model, task, apiSettings, stream, requestOptions);
+async function makeRequest(requestUrlParams, body) {
+    const url = new RequestURL(requestUrlParams);
     let response;
     let fetchTimeoutId;
     try {
-        const request = await constructRequest(model, task, apiSettings, stream, body, requestOptions);
-        // Timeout is 180s by default
-        const timeoutMillis = requestOptions?.timeout != null && requestOptions.timeout >= 0
-            ? requestOptions.timeout
+        const fetchOptions = {
+            method: 'POST',
+            headers: await getHeaders(url),
+            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);
-        request.fetchOptions.signal = abortController.signal;
-        response = await fetch(request.url, request.fetchOptions);
+        fetchOptions.signal = abortController.signal;
+        response = await fetch(url.toString(), fetchOptions);
         if (!response.ok) {
             let message = '';
             let errorDetails;
@@ -1234,7 +1264,7 @@ async function makeRequest(model, task, apiSettings, stream, body, requestOption
                 throw new AIError(AIErrorCode.API_NOT_ENABLED, `The Firebase AI SDK requires the Firebase AI ` +
                     `API ('firebasevertexai.googleapis.com') to be enabled in your ` +
                     `Firebase project. Enable this API by visiting the Firebase Console ` +
-                    `at https://console.firebase.google.com/project/${url.apiSettings.project}/genai/ ` +
+                    `at https://console.firebase.google.com/project/${url.params.apiSettings.project}/genai/ ` +
                     `and clicking "Get started". If you enabled this API recently, ` +
                     `wait a few minutes for the action to propagate to our systems and ` +
                     `then retry.`, {
@@ -1975,8 +2005,13 @@ async function generateContentStreamOnCloud(apiSettings, model, params, requestO
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
-    return makeRequest(model, Task.STREAM_GENERATE_CONTENT, apiSettings, 
-    /* stream */ true, JSON.stringify(params), requestOptions);
+    return makeRequest({
+        task: "streamGenerateContent" /* Task.STREAM_GENERATE_CONTENT */,
+        model,
+        apiSettings,
+        stream: true,
+        requestOptions
+    }, 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));
@@ -1986,8 +2021,37 @@ async function generateContentOnCloud(apiSettings, model, params, requestOptions
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
-    return makeRequest(model, Task.GENERATE_CONTENT, apiSettings, 
-    /* stream */ false, JSON.stringify(params), requestOptions);
+    return makeRequest({
+        model,
+        task: "generateContent" /* Task.GENERATE_CONTENT */,
+        apiSettings,
+        stream: false,
+        requestOptions
+    }, JSON.stringify(params));
+}
+async function templateGenerateContent(apiSettings, templateId, templateParams, requestOptions) {
+    const response = await makeRequest({
+        task: "templateGenerateContent" /* ServerPromptTemplateTask.TEMPLATE_GENERATE_CONTENT */,
+        templateId,
+        apiSettings,
+        stream: false,
+        requestOptions
+    }, JSON.stringify(templateParams));
+    const generateContentResponse = await processGenerateContentResponse(response, apiSettings);
+    const enhancedResponse = createEnhancedContentResponse(generateContentResponse);
+    return {
+        response: enhancedResponse
+    };
+}
+async function templateGenerateContentStream(apiSettings, templateId, templateParams, requestOptions) {
+    const response = await makeRequest({
+        task: "templateStreamGenerateContent" /* ServerPromptTemplateTask.TEMPLATE_STREAM_GENERATE_CONTENT */,
+        templateId,
+        apiSettings,
+        stream: true,
+        requestOptions
+    }, 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));
@@ -2399,7 +2463,13 @@ async function countTokensOnCloud(apiSettings, model, params, requestOptions) {
     else {
         body = JSON.stringify(params);
     }
-    const response = await makeRequest(model, Task.COUNT_TOKENS, apiSettings, false, body, requestOptions);
+    const response = await makeRequest({
+        model,
+        task: "countTokens" /* Task.COUNT_TOKENS */,
+        apiSettings,
+        stream: false,
+        requestOptions
+    }, body);
     return response.json();
 }
 async function countTokens(apiSettings, model, params, chromeAdapter, requestOptions) {
@@ -2952,8 +3022,13 @@ class ImagenModel extends AIModel {
             ...this.generationConfig,
             ...this.safetySettings
         });
-        const response = await makeRequest(this.model, Task.PREDICT, this._apiSettings, 
-        /* stream */ false, JSON.stringify(body), this.requestOptions);
+        const response = await makeRequest({
+            task: "predict" /* Task.PREDICT */,
+            model: this.model,
+            apiSettings: this._apiSettings,
+            stream: false,
+            requestOptions: this.requestOptions
+        }, JSON.stringify(body));
         return handlePredictResponse(response);
     }
     /**
@@ -2981,8 +3056,13 @@ class ImagenModel extends AIModel {
             ...this.generationConfig,
             ...this.safetySettings
         });
-        const response = await makeRequest(this.model, Task.PREDICT, this._apiSettings, 
-        /* stream */ false, JSON.stringify(body), this.requestOptions);
+        const response = await makeRequest({
+            task: "predict" /* Task.PREDICT */,
+            model: this.model,
+            apiSettings: this._apiSettings,
+            stream: false,
+            requestOptions: this.requestOptions
+        }, JSON.stringify(body));
         return handlePredictResponse(response);
     }
 }
@@ -3134,6 +3214,121 @@ class WebSocketHandlerImpl {
     }
 }
 
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * {@link GenerativeModel} APIs that execute on a server-side template.
+ *
+ * This class should only be instantiated with {@link getTemplateGenerativeModel}.
+ *
+ * @beta
+ */
+class TemplateGenerativeModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(ai, requestOptions) {
+        this.requestOptions = requestOptions || {};
+        this._apiSettings = initApiSettings(ai);
+    }
+    /**
+     * Makes a single non-streaming call to the model and returns an object
+     * containing a single {@link GenerateContentResponse}.
+     *
+     * @param templateId - The ID of the server-side template to execute.
+     * @param templateVariables - A key-value map of variables to populate the
+     * template with.
+     *
+     * @beta
+     */
+    async generateContent(templateId, templateVariables // anything!
+    ) {
+        return templateGenerateContent(this._apiSettings, templateId, { inputs: templateVariables }, this.requestOptions);
+    }
+    /**
+     * Makes a single streaming call to the model and returns an object
+     * containing an iterable stream that iterates over all chunks in the
+     * streaming response as well as a promise that returns the final aggregated
+     * response.
+     *
+     * @param templateId - The ID of the server-side template to execute.
+     * @param templateVariables - A key-value map of variables to populate the
+     * template with.
+     *
+     * @beta
+     */
+    async generateContentStream(templateId, templateVariables) {
+        return templateGenerateContentStream(this._apiSettings, templateId, { inputs: templateVariables }, this.requestOptions);
+    }
+}
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Class for Imagen model APIs that execute on a server-side template.
+ *
+ * This class should only be instantiated with {@link getTemplateImagenModel}.
+ *
+ * @beta
+ */
+class TemplateImagenModel {
+    /**
+     * @hideconstructor
+     */
+    constructor(ai, requestOptions) {
+        this.requestOptions = requestOptions || {};
+        this._apiSettings = initApiSettings(ai);
+    }
+    /**
+     * Makes a single call to the model and returns an object containing a single
+     * {@link ImagenGenerationResponse}.
+     *
+     * @param templateId - The ID of the server-side template to execute.
+     * @param templateVariables - A key-value map of variables to populate the
+     * template with.
+     *
+     * @beta
+     */
+    async generateImages(templateId, templateVariables) {
+        const response = await makeRequest({
+            task: "templatePredict" /* ServerPromptTemplateTask.TEMPLATE_PREDICT */,
+            templateId,
+            apiSettings: this._apiSettings,
+            stream: false,
+            requestOptions: this.requestOptions
+        }, JSON.stringify({ inputs: templateVariables }));
+        return handlePredictResponse(response);
+    }
+}
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -3925,6 +4120,30 @@ function getLiveGenerativeModel(ai, modelParams) {
     const webSocketHandler = new WebSocketHandlerImpl();
     return new LiveGenerativeModel(ai, modelParams, webSocketHandler);
 }
+/**
+ * Returns a {@link TemplateGenerativeModel} class for executing server-side
+ * templates.
+ *
+ * @param ai - An {@link AI} instance.
+ * @param requestOptions - Additional options to use when making requests.
+ *
+ * @beta
+ */
+function getTemplateGenerativeModel(ai, requestOptions) {
+    return new TemplateGenerativeModel(ai, requestOptions);
+}
+/**
+ * Returns a {@link TemplateImagenModel} class for executing server-side
+ * Imagen templates.
+ *
+ * @param ai - An {@link AI} instance.
+ * @param requestOptions - Additional options to use when making requests.
+ *
+ * @beta
+ */
+function getTemplateImagenModel(ai, requestOptions) {
+    return new TemplateImagenModel(ai, requestOptions);
+}
 
 /**
  * The Firebase AI Web SDK.
@@ -3979,11 +4198,15 @@ exports.ResponseModality = ResponseModality;
 exports.Schema = Schema;
 exports.SchemaType = SchemaType;
 exports.StringSchema = StringSchema;
+exports.TemplateGenerativeModel = TemplateGenerativeModel;
+exports.TemplateImagenModel = TemplateImagenModel;
 exports.URLRetrievalStatus = URLRetrievalStatus;
 exports.VertexAIBackend = VertexAIBackend;
 exports.getAI = getAI;
 exports.getGenerativeModel = getGenerativeModel;
 exports.getImagenModel = getImagenModel;
 exports.getLiveGenerativeModel = getLiveGenerativeModel;
+exports.getTemplateGenerativeModel = getTemplateGenerativeModel;
+exports.getTemplateImagenModel = getTemplateImagenModel;
 exports.startAudioConversation = startAudioConversation;
 //# sourceMappingURL=index.node.cjs.js.map