@firebase/ai 2.2.1-20250829000033 → 2.2.1-canary.55f3f83a7

package/dist/index.cjs.js

@@ -8,7 +8,7 @@ var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 
 var name = "@firebase/ai";
-var version = "2.2.1-20250829000033";
+var version = "2.2.1-canary.55f3f83a7";
 
 /**
  * @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
@@ -657,105 +713,6 @@ class VertexAIBackend extends Backend {
     }
 }
 
-/**
- * @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.
- */
-class AIService {
-    constructor(app, backend, authProvider, appCheckProvider, chromeAdapterFactory) {
-        this.app = app;
-        this.backend = backend;
-        this.chromeAdapterFactory = chromeAdapterFactory;
-        const appCheck = appCheckProvider?.getImmediate({ optional: true });
-        const auth = authProvider?.getImmediate({ optional: true });
-        this.auth = auth || null;
-        this.appCheck = appCheck || null;
-        if (backend instanceof VertexAIBackend) {
-            this.location = backend.location;
-        }
-        else {
-            this.location = '';
-        }
-    }
-    _delete() {
-        return Promise.resolve();
-    }
-    set options(optionsToSet) {
-        this._options = optionsToSet;
-    }
-    get options() {
-        return this._options;
-    }
-}
-
-/**
- * @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 2025 Google LLC
@@ -816,7 +773,7 @@ function decodeInstanceIdentifier(instanceIdentifier) {
 
 /**
  * @license
- * Copyright 2025 Google LLC
+ * 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.
@@ -830,133 +787,302 @@ function decodeInstanceIdentifier(instanceIdentifier) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const logger = new logger$1.Logger('@firebase/vertexai');
+
 /**
- * Base class for Firebase AI model APIs.
+ * @internal
+ */
+var Availability;
+(function (Availability) {
+    Availability["UNAVAILABLE"] = "unavailable";
+    Availability["DOWNLOADABLE"] = "downloadable";
+    Availability["DOWNLOADING"] = "downloading";
+    Availability["AVAILABLE"] = "available";
+})(Availability || (Availability = {}));
+
+/**
+ * @license
+ * Copyright 2025 Google LLC
  *
- * Instances of this class are associated with a specific Firebase AI {@link Backend}
- * and provide methods for interacting with the configured generative model.
+ * 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
  *
- * @public
+ *   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 AIModel {
+/**
+ * Defines an inference "backend" that uses Chrome's on-device model,
+ * and encapsulates logic for detecting when on-device inference is
+ * possible.
+ */
+class ChromeAdapterImpl {
+    constructor(languageModelProvider, mode, onDeviceParams = {
+        createOptions: {
+            // Defaults to support image inputs for convenience.
+            expectedInputs: [{ type: 'image' }]
+        }
+    }) {
+        this.languageModelProvider = languageModelProvider;
+        this.mode = mode;
+        this.onDeviceParams = onDeviceParams;
+        this.isDownloading = false;
+    }
     /**
-     * Constructs a new instance of the {@link AIModel} class.
-     *
-     * This constructor should only be called from subclasses that provide
-     * a model API.
+     * Checks if a given request can be made on-device.
      *
-     * @param ai - an {@link AI} instance.
-     * @param modelName - The name of the model being used. It can be in one of the following formats:
-     * - `my-model` (short name, will resolve to `publishers/google/models/my-model`)
-     * - `models/my-model` (will resolve to `publishers/google/models/my-model`)
-     * - `publishers/my-publisher/models/my-model` (fully qualified model name)
+     * Encapsulates a few concerns:
+     *   the mode
+     *   API existence
+     *   prompt formatting
+     *   model availability, including triggering download if necessary
      *
-     * @throws If the `apiKey` or `projectId` fields are missing in your
-     * Firebase config.
      *
-     * @internal
+     * Pros: callers needn't be concerned with details of on-device availability.</p>
+     * Cons: this method spans a few concerns and splits request validation from usage.
+     * If instance variables weren't already part of the API, we could consider a better
+     * separation of concerns.
      */
-    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.`);
+    async isAvailable(request) {
+        if (!this.mode) {
+            logger.debug(`On-device inference unavailable because mode is undefined.`);
+            return false;
         }
-        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.`);
+        if (this.mode === InferenceMode.ONLY_IN_CLOUD) {
+            logger.debug(`On-device inference unavailable because mode is "only_in_cloud".`);
+            return false;
         }
-        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.`);
+        // Triggers out-of-band download so model will eventually become available.
+        const availability = await this.downloadIfAvailable();
+        if (this.mode === InferenceMode.ONLY_ON_DEVICE) {
+            // If it will never be available due to API inavailability, throw.
+            if (availability === Availability.UNAVAILABLE) {
+                throw new AIError(AIErrorCode.API_NOT_ENABLED, 'Local LanguageModel API not available in this environment.');
+            }
+            else if (availability === Availability.DOWNLOADABLE ||
+                availability === Availability.DOWNLOADING) {
+                // TODO(chholland): Better user experience during download - progress?
+                logger.debug(`Waiting for download of LanguageModel to complete.`);
+                await this.downloadPromise;
+                return true;
+            }
+            return true;
         }
-        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 });
-                };
+        // Applies prefer_on_device logic.
+        if (availability !== Availability.AVAILABLE) {
+            logger.debug(`On-device inference unavailable because availability is "${availability}".`);
+            return false;
+        }
+        if (!ChromeAdapterImpl.isOnDeviceRequest(request)) {
+            logger.debug(`On-device inference unavailable because request is incompatible.`);
+            return false;
+        }
+        return true;
+    }
+    /**
+     * Generates content on device.
+     *
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContent} for generating content in
+     * Cloud.
+     * @param request - a standard Firebase AI {@link GenerateContentRequest}
+     * @returns {@link Response}, so we can reuse common response formatting.
+     */
+    async generateContent(request) {
+        const session = await this.createSession();
+        const contents = await Promise.all(request.contents.map(ChromeAdapterImpl.toLanguageModelMessage));
+        const text = await session.prompt(contents, this.onDeviceParams.promptOptions);
+        return ChromeAdapterImpl.toResponse(text);
+    }
+    /**
+     * Generates content stream on device.
+     *
+     * @remarks
+     * This is comparable to {@link GenerativeModel.generateContentStream} for generating content in
+     * Cloud.
+     * @param request - a standard Firebase AI {@link GenerateContentRequest}
+     * @returns {@link Response}, so we can reuse common response formatting.
+     */
+    async generateContentStream(request) {
+        const session = await this.createSession();
+        const contents = await Promise.all(request.contents.map(ChromeAdapterImpl.toLanguageModelMessage));
+        const stream = session.promptStreaming(contents, this.onDeviceParams.promptOptions);
+        return ChromeAdapterImpl.toStreamResponse(stream);
+    }
+    async countTokens(_request) {
+        throw new AIError(AIErrorCode.REQUEST_ERROR, 'Count Tokens is not yet available for on-device model.');
+    }
+    /**
+     * Asserts inference for the given request can be performed by an on-device model.
+     */
+    static isOnDeviceRequest(request) {
+        // Returns false if the prompt is empty.
+        if (request.contents.length === 0) {
+            logger.debug('Empty prompt rejected for on-device inference.');
+            return false;
+        }
+        for (const content of request.contents) {
+            if (content.role === 'function') {
+                logger.debug(`"Function" role rejected for on-device inference.`);
+                return false;
             }
-            else if (ai.appCheck) {
-                if (ai.options?.useLimitedUseAppCheckTokens) {
-                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getLimitedUseToken();
-                }
-                else {
-                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
+            // Returns false if request contains an image with an unsupported mime type.
+            for (const part of content.parts) {
+                if (part.inlineData &&
+                    ChromeAdapterImpl.SUPPORTED_MIME_TYPES.indexOf(part.inlineData.mimeType) === -1) {
+                    logger.debug(`Unsupported mime type "${part.inlineData.mimeType}" rejected for on-device inference.`);
+                    return false;
                 }
             }
-            if (ai.auth) {
-                this._apiSettings.getAuthToken = () => ai.auth.getToken();
-            }
-            this.model = AIModel.normalizeModelName(modelName, this._apiSettings.backend.backendType);
         }
+        return true;
     }
     /**
-     * Normalizes the given model name to a fully qualified model resource name.
+     * Encapsulates logic to get availability and download a model if one is downloadable.
+     */
+    async downloadIfAvailable() {
+        const availability = await this.languageModelProvider?.availability(this.onDeviceParams.createOptions);
+        if (availability === Availability.DOWNLOADABLE) {
+            this.download();
+        }
+        return availability;
+    }
+    /**
+     * Triggers out-of-band download of an on-device model.
      *
-     * @param modelName - The model name to normalize.
-     * @returns The fully qualified model resource name.
+     * Chrome only downloads models as needed. Chrome knows a model is needed when code calls
+     * LanguageModel.create.
      *
-     * @internal
+     * Since Chrome manages the download, the SDK can only avoid redundant download requests by
+     * tracking if a download has previously been requested.
      */
-    static normalizeModelName(modelName, backendType) {
-        if (backendType === BackendType.GOOGLE_AI) {
-            return AIModel.normalizeGoogleAIModelName(modelName);
+    download() {
+        if (this.isDownloading) {
+            return;
         }
-        else {
-            return AIModel.normalizeVertexAIModelName(modelName);
+        this.isDownloading = true;
+        this.downloadPromise = this.languageModelProvider
+            ?.create(this.onDeviceParams.createOptions)
+            .finally(() => {
+            this.isDownloading = false;
+        });
+    }
+    /**
+     * Converts Firebase AI {@link Content} object to a Chrome {@link LanguageModelMessage} object.
+     */
+    static async toLanguageModelMessage(content) {
+        const languageModelMessageContents = await Promise.all(content.parts.map(ChromeAdapterImpl.toLanguageModelMessageContent));
+        return {
+            role: ChromeAdapterImpl.toLanguageModelMessageRole(content.role),
+            content: languageModelMessageContents
+        };
+    }
+    /**
+     * Converts a Firebase AI Part object to a Chrome LanguageModelMessageContent object.
+     */
+    static async toLanguageModelMessageContent(part) {
+        if (part.text) {
+            return {
+                type: 'text',
+                value: part.text
+            };
+        }
+        else if (part.inlineData) {
+            const formattedImageContent = await fetch(`data:${part.inlineData.mimeType};base64,${part.inlineData.data}`);
+            const imageBlob = await formattedImageContent.blob();
+            const imageBitmap = await createImageBitmap(imageBlob);
+            return {
+                type: 'image',
+                value: imageBitmap
+            };
         }
+        throw new AIError(AIErrorCode.REQUEST_ERROR, `Processing of this Part type is not currently supported.`);
     }
     /**
-     * @internal
+     * Converts a Firebase AI {@link Role} string to a {@link LanguageModelMessageRole} string.
      */
-    static normalizeGoogleAIModelName(modelName) {
-        return `models/${modelName}`;
+    static toLanguageModelMessageRole(role) {
+        // Assumes 'function' rule has been filtered by isOnDeviceRequest
+        return role === 'model' ? 'assistant' : 'user';
     }
     /**
-     * @internal
+     * Abstracts Chrome session creation.
+     *
+     * Chrome uses a multi-turn session for all inference. Firebase AI uses single-turn for all
+     * inference. To map the Firebase AI API to Chrome's API, the SDK creates a new session for all
+     * inference.
+     *
+     * Chrome will remove a model from memory if it's no longer in use, so this method ensures a
+     * new session is created before an old session is destroyed.
      */
-    static normalizeVertexAIModelName(modelName) {
-        let model;
-        if (modelName.includes('/')) {
-            if (modelName.startsWith('models/')) {
-                // Add 'publishers/google' if the user is only passing in 'models/model-name'.
-                model = `publishers/google/${modelName}`;
-            }
-            else {
-                // Any other custom format (e.g. tuned models) must be passed in correctly.
-                model = modelName;
-            }
+    async createSession() {
+        if (!this.languageModelProvider) {
+            throw new AIError(AIErrorCode.UNSUPPORTED, 'Chrome AI requested for unsupported browser version.');
         }
-        else {
-            // If path is not included, assume it's a non-tuned model.
-            model = `publishers/google/models/${modelName}`;
+        const newSession = await this.languageModelProvider.create(this.onDeviceParams.createOptions);
+        if (this.oldSession) {
+            this.oldSession.destroy();
         }
-        return model;
+        // Holds session reference, so model isn't unloaded from memory.
+        this.oldSession = newSession;
+        return newSession;
+    }
+    /**
+     * Formats string returned by Chrome as a {@link Response} returned by Firebase AI.
+     */
+    static toResponse(text) {
+        return {
+            json: async () => ({
+                candidates: [
+                    {
+                        content: {
+                            parts: [{ text }]
+                        }
+                    }
+                ]
+            })
+        };
+    }
+    /**
+     * Formats string stream returned by Chrome as SSE returned by Firebase AI.
+     */
+    static toStreamResponse(stream) {
+        const encoder = new TextEncoder();
+        return {
+            body: stream.pipeThrough(new TransformStream({
+                transform(chunk, controller) {
+                    const json = JSON.stringify({
+                        candidates: [
+                            {
+                                content: {
+                                    role: 'model',
+                                    parts: [{ text: chunk }]
+                                }
+                            }
+                        ]
+                    });
+                    controller.enqueue(encoder.encode(`data: ${json}\n\n`));
+                }
+            }))
+        };
     }
 }
-
+// Visible for testing
+ChromeAdapterImpl.SUPPORTED_MIME_TYPES = ['image/jpeg', 'image/png'];
 /**
- * @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.
+ * Creates a ChromeAdapterImpl on demand.
  */
-const logger = new logger$1.Logger('@firebase/vertexai');
+function chromeAdapterFactory(mode, window, params) {
+    // Do not initialize a ChromeAdapter if we are not in hybrid mode.
+    if (typeof window !== 'undefined' && mode) {
+        return new ChromeAdapterImpl(window.LanguageModel, mode, params);
+    }
+}
 
 /**
  * @license
@@ -974,8 +1100,205 @@ 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) {
+class AIService {
+    constructor(app, backend, authProvider, appCheckProvider, chromeAdapterFactory) {
+        this.app = app;
+        this.backend = backend;
+        this.chromeAdapterFactory = chromeAdapterFactory;
+        const appCheck = appCheckProvider?.getImmediate({ optional: true });
+        const auth = authProvider?.getImmediate({ optional: true });
+        this.auth = auth || null;
+        this.appCheck = appCheck || null;
+        if (backend instanceof VertexAIBackend) {
+            this.location = backend.location;
+        }
+        else {
+            this.location = '';
+        }
+    }
+    _delete() {
+        return Promise.resolve();
+    }
+    set options(optionsToSet) {
+        this._options = optionsToSet;
+    }
+    get options() {
+        return this._options;
+    }
+}
+
+/**
+ * @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.
+ */
+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, chromeAdapterFactory);
+}
+
+/**
+ * @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.
+ */
+/**
+ * Base class for Firebase AI model APIs.
+ *
+ * Instances of this class are associated with a specific Firebase AI {@link Backend}
+ * and provide methods for interacting with the configured generative model.
+ *
+ * @public
+ */
+class AIModel {
+    /**
+     * Constructs a new instance of the {@link AIModel} class.
+     *
+     * This constructor should only be called from subclasses that provide
+     * a model API.
+     *
+     * @param ai - an {@link AI} instance.
+     * @param modelName - The name of the model being used. It can be in one of the following formats:
+     * - `my-model` (short name, will resolve to `publishers/google/models/my-model`)
+     * - `models/my-model` (will resolve to `publishers/google/models/my-model`)
+     * - `publishers/my-publisher/models/my-model` (fully qualified model name)
+     *
+     * @throws If the `apiKey` or `projectId` fields are missing in your
+     * Firebase config.
+     *
+     * @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);
+        }
+    }
+    /**
+     * Normalizes the given model name to a fully qualified model resource name.
+     *
+     * @param modelName - The model name to normalize.
+     * @returns The fully qualified model resource name.
+     *
+     * @internal
+     */
+    static normalizeModelName(modelName, backendType) {
+        if (backendType === BackendType.GOOGLE_AI) {
+            return AIModel.normalizeGoogleAIModelName(modelName);
+        }
+        else {
+            return AIModel.normalizeVertexAIModelName(modelName);
+        }
+    }
+    /**
+     * @internal
+     */
+    static normalizeGoogleAIModelName(modelName) {
+        return `models/${modelName}`;
+    }
+    /**
+     * @internal
+     */
+    static normalizeVertexAIModelName(modelName) {
+        let model;
+        if (modelName.includes('/')) {
+            if (modelName.startsWith('models/')) {
+                // Add 'publishers/google' if the user is only passing in 'models/model-name'.
+                model = `publishers/google/${modelName}`;
+            }
+            else {
+                // Any other custom format (e.g. tuned models) must be passed in correctly.
+                model = modelName;
+            }
+        }
+        else {
+            // If path is not included, assume it's a non-tuned model.
+            model = `publishers/google/models/${modelName}`;
+        }
+        return model;
+    }
+}
+
+/**
+ * @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.
+ */
+var Task;
+(function (Task) {
     Task["GENERATE_CONTENT"] = "generateContent";
     Task["STREAM_GENERATE_CONTENT"] = "streamGenerateContent";
     Task["COUNT_TOKENS"] = "countTokens";
@@ -3610,317 +3933,11 @@ function getLiveGenerativeModel(ai, modelParams) {
     return new LiveGenerativeModel(ai, modelParams, webSocketHandler);
 }
 
-/**
- * @internal
- */
-var Availability;
-(function (Availability) {
-    Availability["UNAVAILABLE"] = "unavailable";
-    Availability["DOWNLOADABLE"] = "downloadable";
-    Availability["DOWNLOADING"] = "downloading";
-    Availability["AVAILABLE"] = "available";
-})(Availability || (Availability = {}));
-
-/**
- * @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.
- */
-/**
- * Defines an inference "backend" that uses Chrome's on-device model,
- * and encapsulates logic for detecting when on-device inference is
- * possible.
- */
-class ChromeAdapterImpl {
-    constructor(languageModelProvider, mode, onDeviceParams = {
-        createOptions: {
-            // Defaults to support image inputs for convenience.
-            expectedInputs: [{ type: 'image' }]
-        }
-    }) {
-        this.languageModelProvider = languageModelProvider;
-        this.mode = mode;
-        this.onDeviceParams = onDeviceParams;
-        this.isDownloading = false;
-    }
-    /**
-     * Checks if a given request can be made on-device.
-     *
-     * Encapsulates a few concerns:
-     *   the mode
-     *   API existence
-     *   prompt formatting
-     *   model availability, including triggering download if necessary
-     *
-     *
-     * Pros: callers needn't be concerned with details of on-device availability.</p>
-     * Cons: this method spans a few concerns and splits request validation from usage.
-     * If instance variables weren't already part of the API, we could consider a better
-     * separation of concerns.
-     */
-    async isAvailable(request) {
-        if (!this.mode) {
-            logger.debug(`On-device inference unavailable because mode is undefined.`);
-            return false;
-        }
-        if (this.mode === InferenceMode.ONLY_IN_CLOUD) {
-            logger.debug(`On-device inference unavailable because mode is "only_in_cloud".`);
-            return false;
-        }
-        // Triggers out-of-band download so model will eventually become available.
-        const availability = await this.downloadIfAvailable();
-        if (this.mode === InferenceMode.ONLY_ON_DEVICE) {
-            // If it will never be available due to API inavailability, throw.
-            if (availability === Availability.UNAVAILABLE) {
-                throw new AIError(AIErrorCode.API_NOT_ENABLED, 'Local LanguageModel API not available in this environment.');
-            }
-            else if (availability === Availability.DOWNLOADABLE ||
-                availability === Availability.DOWNLOADING) {
-                // TODO(chholland): Better user experience during download - progress?
-                logger.debug(`Waiting for download of LanguageModel to complete.`);
-                await this.downloadPromise;
-                return true;
-            }
-            return true;
-        }
-        // Applies prefer_on_device logic.
-        if (availability !== Availability.AVAILABLE) {
-            logger.debug(`On-device inference unavailable because availability is "${availability}".`);
-            return false;
-        }
-        if (!ChromeAdapterImpl.isOnDeviceRequest(request)) {
-            logger.debug(`On-device inference unavailable because request is incompatible.`);
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Generates content on device.
-     *
-     * @remarks
-     * This is comparable to {@link GenerativeModel.generateContent} for generating content in
-     * Cloud.
-     * @param request - a standard Firebase AI {@link GenerateContentRequest}
-     * @returns {@link Response}, so we can reuse common response formatting.
-     */
-    async generateContent(request) {
-        const session = await this.createSession();
-        const contents = await Promise.all(request.contents.map(ChromeAdapterImpl.toLanguageModelMessage));
-        const text = await session.prompt(contents, this.onDeviceParams.promptOptions);
-        return ChromeAdapterImpl.toResponse(text);
-    }
-    /**
-     * Generates content stream on device.
-     *
-     * @remarks
-     * This is comparable to {@link GenerativeModel.generateContentStream} for generating content in
-     * Cloud.
-     * @param request - a standard Firebase AI {@link GenerateContentRequest}
-     * @returns {@link Response}, so we can reuse common response formatting.
-     */
-    async generateContentStream(request) {
-        const session = await this.createSession();
-        const contents = await Promise.all(request.contents.map(ChromeAdapterImpl.toLanguageModelMessage));
-        const stream = session.promptStreaming(contents, this.onDeviceParams.promptOptions);
-        return ChromeAdapterImpl.toStreamResponse(stream);
-    }
-    async countTokens(_request) {
-        throw new AIError(AIErrorCode.REQUEST_ERROR, 'Count Tokens is not yet available for on-device model.');
-    }
-    /**
-     * Asserts inference for the given request can be performed by an on-device model.
-     */
-    static isOnDeviceRequest(request) {
-        // Returns false if the prompt is empty.
-        if (request.contents.length === 0) {
-            logger.debug('Empty prompt rejected for on-device inference.');
-            return false;
-        }
-        for (const content of request.contents) {
-            if (content.role === 'function') {
-                logger.debug(`"Function" role rejected for on-device inference.`);
-                return false;
-            }
-            // Returns false if request contains an image with an unsupported mime type.
-            for (const part of content.parts) {
-                if (part.inlineData &&
-                    ChromeAdapterImpl.SUPPORTED_MIME_TYPES.indexOf(part.inlineData.mimeType) === -1) {
-                    logger.debug(`Unsupported mime type "${part.inlineData.mimeType}" rejected for on-device inference.`);
-                    return false;
-                }
-            }
-        }
-        return true;
-    }
-    /**
-     * Encapsulates logic to get availability and download a model if one is downloadable.
-     */
-    async downloadIfAvailable() {
-        const availability = await this.languageModelProvider?.availability(this.onDeviceParams.createOptions);
-        if (availability === Availability.DOWNLOADABLE) {
-            this.download();
-        }
-        return availability;
-    }
-    /**
-     * Triggers out-of-band download of an on-device model.
-     *
-     * Chrome only downloads models as needed. Chrome knows a model is needed when code calls
-     * LanguageModel.create.
-     *
-     * Since Chrome manages the download, the SDK can only avoid redundant download requests by
-     * tracking if a download has previously been requested.
-     */
-    download() {
-        if (this.isDownloading) {
-            return;
-        }
-        this.isDownloading = true;
-        this.downloadPromise = this.languageModelProvider
-            ?.create(this.onDeviceParams.createOptions)
-            .finally(() => {
-            this.isDownloading = false;
-        });
-    }
-    /**
-     * Converts Firebase AI {@link Content} object to a Chrome {@link LanguageModelMessage} object.
-     */
-    static async toLanguageModelMessage(content) {
-        const languageModelMessageContents = await Promise.all(content.parts.map(ChromeAdapterImpl.toLanguageModelMessageContent));
-        return {
-            role: ChromeAdapterImpl.toLanguageModelMessageRole(content.role),
-            content: languageModelMessageContents
-        };
-    }
-    /**
-     * Converts a Firebase AI Part object to a Chrome LanguageModelMessageContent object.
-     */
-    static async toLanguageModelMessageContent(part) {
-        if (part.text) {
-            return {
-                type: 'text',
-                value: part.text
-            };
-        }
-        else if (part.inlineData) {
-            const formattedImageContent = await fetch(`data:${part.inlineData.mimeType};base64,${part.inlineData.data}`);
-            const imageBlob = await formattedImageContent.blob();
-            const imageBitmap = await createImageBitmap(imageBlob);
-            return {
-                type: 'image',
-                value: imageBitmap
-            };
-        }
-        throw new AIError(AIErrorCode.REQUEST_ERROR, `Processing of this Part type is not currently supported.`);
-    }
-    /**
-     * Converts a Firebase AI {@link Role} string to a {@link LanguageModelMessageRole} string.
-     */
-    static toLanguageModelMessageRole(role) {
-        // Assumes 'function' rule has been filtered by isOnDeviceRequest
-        return role === 'model' ? 'assistant' : 'user';
-    }
-    /**
-     * Abstracts Chrome session creation.
-     *
-     * Chrome uses a multi-turn session for all inference. Firebase AI uses single-turn for all
-     * inference. To map the Firebase AI API to Chrome's API, the SDK creates a new session for all
-     * inference.
-     *
-     * Chrome will remove a model from memory if it's no longer in use, so this method ensures a
-     * new session is created before an old session is destroyed.
-     */
-    async createSession() {
-        if (!this.languageModelProvider) {
-            throw new AIError(AIErrorCode.UNSUPPORTED, 'Chrome AI requested for unsupported browser version.');
-        }
-        const newSession = await this.languageModelProvider.create(this.onDeviceParams.createOptions);
-        if (this.oldSession) {
-            this.oldSession.destroy();
-        }
-        // Holds session reference, so model isn't unloaded from memory.
-        this.oldSession = newSession;
-        return newSession;
-    }
-    /**
-     * Formats string returned by Chrome as a {@link Response} returned by Firebase AI.
-     */
-    static toResponse(text) {
-        return {
-            json: async () => ({
-                candidates: [
-                    {
-                        content: {
-                            parts: [{ text }]
-                        }
-                    }
-                ]
-            })
-        };
-    }
-    /**
-     * Formats string stream returned by Chrome as SSE returned by Firebase AI.
-     */
-    static toStreamResponse(stream) {
-        const encoder = new TextEncoder();
-        return {
-            body: stream.pipeThrough(new TransformStream({
-                transform(chunk, controller) {
-                    const json = JSON.stringify({
-                        candidates: [
-                            {
-                                content: {
-                                    role: 'model',
-                                    parts: [{ text: chunk }]
-                                }
-                            }
-                        ]
-                    });
-                    controller.enqueue(encoder.encode(`data: ${json}\n\n`));
-                }
-            }))
-        };
-    }
-}
-// Visible for testing
-ChromeAdapterImpl.SUPPORTED_MIME_TYPES = ['image/jpeg', 'image/png'];
-/**
- * Creates a ChromeAdapterImpl on demand.
- */
-function chromeAdapterFactory(mode, window, params) {
-    // Do not initialize a ChromeAdapter if we are not in hybrid mode.
-    if (typeof window !== 'undefined' && mode) {
-        return new ChromeAdapterImpl(window.LanguageModel, mode, params);
-    }
-}
-
 /**
  * The Firebase AI Web SDK.
  *
  * @packageDocumentation
  */
-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, chromeAdapterFactory);
-}
 function registerAI() {
     app._registerComponent(new component.Component(AI_TYPE, factory, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));
     app.registerVersion(name, version);