@firebase/ai 2.5.0 → 2.6.0-20251112180857

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";
+var version = "2.6.0-20251112180857";
 
 /**
  * @license
@@ -38,6 +38,62 @@ const DEFAULT_FETCH_TIMEOUT_MS = 180 * 1000;
  */
 const DEFAULT_HYBRID_IN_CLOUD_MODEL = 'gemini-2.0-flash-lite';
 
+/**
+ * @license
+ * Copyright 2024 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.
+ */
+/**
+ * Error class for the Firebase AI SDK.
+ *
+ * @public
+ */
+class AIError extends util.FirebaseError {
+    /**
+     * Constructs a new instance of the `AIError` class.
+     *
+     * @param code - The error code from {@link (AIErrorCode:type)}.
+     * @param message - A human-readable message describing the error.
+     * @param customErrorData - Optional error data.
+     */
+    constructor(code, message, customErrorData) {
+        // Match error format used by FirebaseError from ErrorFactory
+        const service = AI_TYPE;
+        const fullCode = `${service}/${code}`;
+        const fullMessage = `${service}: ${message} (${fullCode})`;
+        super(code, fullMessage);
+        this.code = code;
+        this.customErrorData = customErrorData;
+        // FirebaseError initializes a stack trace, but it assumes the error is created from the error
+        // factory. Since we break this assumption, we set the stack trace to be originating from this
+        // constructor.
+        // This is only supported in V8.
+        if (Error.captureStackTrace) {
+            // Allows us to initialize the stack trace without including the constructor itself at the
+            // top level of the stack trace.
+            Error.captureStackTrace(this, AIError);
+        }
+        // Allows instanceof AIError in ES5/ES6
+        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+        // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
+        //                   which we can now use since we no longer target ES5.
+        Object.setPrototypeOf(this, AIError.prototype);
+        // Since Error is an interface, we don't inherit toString and so we define it ourselves.
+        this.toString = () => fullMessage;
+    }
+}
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -714,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.
@@ -740,6 +808,76 @@ 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}`;
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * Encodes a {@link Backend} into a string that will be used to uniquely identify {@link AI}
+ * instances by backend type.
+ *
+ * @internal
+ */
+function encodeInstanceIdentifier(backend) {
+    if (backend instanceof GoogleAIBackend) {
+        return `${AI_TYPE}/googleai`;
+    }
+    else if (backend instanceof VertexAIBackend) {
+        return `${AI_TYPE}/vertexai/${backend.location}`;
+    }
+    else {
+        throw new AIError(AIErrorCode.ERROR, `Invalid backend: ${JSON.stringify(backend.backendType)}`);
+    }
+}
+/**
+ * Decodes an instance identifier string into a {@link Backend}.
+ *
+ * @internal
+ */
+function decodeInstanceIdentifier(instanceIdentifier) {
+    const identifierParts = instanceIdentifier.split('/');
+    if (identifierParts[0] !== AI_TYPE) {
+        throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier, unknown prefix '${identifierParts[0]}'`);
+    }
+    const backendType = identifierParts[1];
+    switch (backendType) {
+        case 'vertexai':
+            const location = identifierParts[2];
+            if (!location) {
+                throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier, unknown location '${instanceIdentifier}'`);
+            }
+            return new VertexAIBackend(location);
+        case 'googleai':
+            return new GoogleAIBackend();
+        default:
+            throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier string: '${instanceIdentifier}'`);
+    }
 }
 
 /**
@@ -787,7 +925,7 @@ class AIService {
 
 /**
  * @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.
@@ -801,44 +939,16 @@ class AIService {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-/**
- * Error class for the Firebase AI SDK.
- *
- * @public
- */
-class AIError extends util.FirebaseError {
-    /**
-     * Constructs a new instance of the `AIError` class.
-     *
-     * @param code - The error code from {@link (AIErrorCode:type)}.
-     * @param message - A human-readable message describing the error.
-     * @param customErrorData - Optional error data.
-     */
-    constructor(code, message, customErrorData) {
-        // Match error format used by FirebaseError from ErrorFactory
-        const service = AI_TYPE;
-        const fullCode = `${service}/${code}`;
-        const fullMessage = `${service}: ${message} (${fullCode})`;
-        super(code, fullMessage);
-        this.code = code;
-        this.customErrorData = customErrorData;
-        // FirebaseError initializes a stack trace, but it assumes the error is created from the error
-        // factory. Since we break this assumption, we set the stack trace to be originating from this
-        // constructor.
-        // This is only supported in V8.
-        if (Error.captureStackTrace) {
-            // Allows us to initialize the stack trace without including the constructor itself at the
-            // top level of the stack trace.
-            Error.captureStackTrace(this, AIError);
-        }
-        // Allows instanceof AIError in ES5/ES6
-        // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
-        // TODO(dlarocque): Replace this with `new.target`: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html#support-for-newtarget
-        //                   which we can now use since we no longer target ES5.
-        Object.setPrototypeOf(this, AIError.prototype);
-        // Since Error is an interface, we don't inherit toString and so we define it ourselves.
-        this.toString = () => fullMessage;
-    }
+function factory(container, { instanceIdentifier }) {
+    if (!instanceIdentifier) {
+        throw new AIError(AIErrorCode.ERROR, 'AIService instance identifier is undefined.');
+    }
+    const backend = decodeInstanceIdentifier(instanceIdentifier);
+    // getImmediate for FirebaseApp will always succeed
+    const app = container.getProvider('app').getImmediate();
+    const auth = container.getProvider('auth-internal');
+    const appCheckProvider = container.getProvider('app-check-internal');
+    return new AIService(app, backend, auth, appCheckProvider);
 }
 
 /**
@@ -858,45 +968,48 @@ class AIError extends util.FirebaseError {
  * limitations under the License.
  */
 /**
- * Encodes a {@link Backend} into a string that will be used to uniquely identify {@link AI}
- * instances by backend type.
+ * Initializes an {@link ApiSettings} object from an {@link AI} instance.
  *
- * @internal
+ * 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 encodeInstanceIdentifier(backend) {
-    if (backend instanceof GoogleAIBackend) {
-        return `${AI_TYPE}/googleai`;
-    }
-    else if (backend instanceof VertexAIBackend) {
-        return `${AI_TYPE}/vertexai/${backend.location}`;
-    }
-    else {
-        throw new AIError(AIErrorCode.ERROR, `Invalid backend: ${JSON.stringify(backend.backendType)}`);
+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 });
+        };
     }
-}
-/**
- * Decodes an instance identifier string into a {@link Backend}.
- *
- * @internal
- */
-function decodeInstanceIdentifier(instanceIdentifier) {
-    const identifierParts = instanceIdentifier.split('/');
-    if (identifierParts[0] !== AI_TYPE) {
-        throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier, unknown prefix '${identifierParts[0]}'`);
+    else if (ai.appCheck) {
+        if (ai.options?.useLimitedUseAppCheckTokens) {
+            apiSettings.getAppCheckToken = () => ai.appCheck.getLimitedUseToken();
+        }
+        else {
+            apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
+        }
     }
-    const backendType = identifierParts[1];
-    switch (backendType) {
-        case 'vertexai':
-            const location = identifierParts[2];
-            if (!location) {
-                throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier, unknown location '${instanceIdentifier}'`);
-            }
-            return new VertexAIBackend(location);
-        case 'googleai':
-            return new GoogleAIBackend();
-        default:
-            throw new AIError(AIErrorCode.ERROR, `Invalid instance identifier string: '${instanceIdentifier}'`);
+    if (ai.auth) {
+        apiSettings.getAuthToken = () => ai.auth.getToken();
     }
+    return apiSettings;
 }
 
 /**
@@ -942,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.
@@ -1045,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.
@@ -1059,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;
@@ -1139,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) {
@@ -1152,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;
@@ -1206,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.`, {
@@ -1947,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));
@@ -1958,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));
@@ -2371,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) {
@@ -2924,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);
     }
     /**
@@ -2953,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);
     }
 }
@@ -3106,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
@@ -3897,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.
@@ -3904,17 +4151,7 @@ function getLiveGenerativeModel(ai, modelParams) {
  * @packageDocumentation
  */
 function registerAI() {
-    app._registerComponent(new component.Component(AI_TYPE, (container, { instanceIdentifier }) => {
-        if (!instanceIdentifier) {
-            throw new AIError(AIErrorCode.ERROR, 'AIService instance identifier is undefined.');
-        }
-        const backend = decodeInstanceIdentifier(instanceIdentifier);
-        // getImmediate for FirebaseApp will always succeed
-        const app = container.getProvider('app').getImmediate();
-        const auth = container.getProvider('auth-internal');
-        const appCheckProvider = container.getProvider('app-check-internal');
-        return new AIService(app, backend, auth, appCheckProvider);
-    }, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
+    app._registerComponent(new component.Component(AI_TYPE, factory, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     app.registerVersion(name, version, 'node');
     // BUILD_TARGET will be replaced by values like esm, cjs, etc during the compilation
     app.registerVersion(name, version, 'cjs2020');
@@ -3961,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