@firebase/ai 2.1.0-canary.9b63cd60e → 2.1.0-canary.cbef6c6e5

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.1.0-canary.9b63cd60e";
+var version = "2.1.0-canary.cbef6c6e5";
 
 /**
  * @license
@@ -640,9 +640,10 @@ class VertexAIBackend extends Backend {
  * limitations under the License.
  */
 class AIService {
-    constructor(app, backend, authProvider, appCheckProvider) {
+    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;
@@ -1328,8 +1329,9 @@ async function handlePredictResponse(response) {
                 gcsURI: prediction.gcsUri
             });
         }
+        else if (prediction.safetyAttributes) ;
         else {
-            throw new AIError(AIErrorCode.RESPONSE_ERROR, `Predictions array in response has missing properties. Response: ${JSON.stringify(responseJson)}`);
+            throw new AIError(AIErrorCode.RESPONSE_ERROR, `Unexpected element in 'predictions' array in response: '${JSON.stringify(prediction)}'`);
         }
     }
     return { images, filteredReason };
@@ -1870,7 +1872,8 @@ function createPredictRequestBody(prompt, { gcsURI, imageFormat, addWatermark, n
             addWatermark,
             safetyFilterLevel,
             personGeneration: personFilterLevel,
-            includeRaiReason: true
+            includeRaiReason: true,
+            includeSafetyAttributes: true
         }
     };
     return body;
@@ -2349,20 +2352,9 @@ class ImagenModel extends AIModel {
     }
 }
 
-/**
- * @internal
- */
-var Availability;
-(function (Availability) {
-    Availability["UNAVAILABLE"] = "unavailable";
-    Availability["DOWNLOADABLE"] = "downloadable";
-    Availability["DOWNLOADING"] = "downloading";
-    Availability["AVAILABLE"] = "available";
-})(Availability || (Availability = {}));
-
 /**
  * @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.
@@ -2377,362 +2369,87 @@ var Availability;
  * 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.
+ * Parent class encompassing all Schema types, with static methods that
+ * allow building specific Schema types. This class can be converted with
+ * `JSON.stringify()` into a JSON string accepted by Vertex AI REST endpoints.
+ * (This string conversion is automatically done when calling SDK methods.)
+ * @public
  */
-class ChromeAdapterImpl {
-    constructor(languageModelProvider, mode, onDeviceParams = {
-        createOptions: {
-            // Defaults to support image inputs for convenience.
-            expectedInputs: [{ type: 'image' }]
+class Schema {
+    constructor(schemaParams) {
+        // TODO(dlarocque): Enforce this with union types
+        if (!schemaParams.type && !schemaParams.anyOf) {
+            throw new AIError(AIErrorCode.INVALID_SCHEMA, "A schema must have either a 'type' or an 'anyOf' array of sub-schemas.");
         }
-    }) {
-        this.languageModelProvider = languageModelProvider;
-        this.mode = mode;
-        this.onDeviceParams = onDeviceParams;
-        this.isDownloading = false;
+        // eslint-disable-next-line guard-for-in
+        for (const paramKey in schemaParams) {
+            this[paramKey] = schemaParams[paramKey];
+        }
+        // Ensure these are explicitly set to avoid TS errors.
+        this.type = schemaParams.type;
+        this.format = schemaParams.hasOwnProperty('format')
+            ? schemaParams.format
+            : undefined;
+        this.nullable = schemaParams.hasOwnProperty('nullable')
+            ? !!schemaParams.nullable
+            : 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.
+     * Defines how this Schema should be serialized as JSON.
+     * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#tojson_behavior
+     * @internal
      */
-    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;
+    toJSON() {
+        const obj = {
+            type: this.type
+        };
+        for (const prop in this) {
+            if (this.hasOwnProperty(prop) && this[prop] !== undefined) {
+                if (prop !== 'required' || this.type === SchemaType.OBJECT) {
+                    obj[prop] = this[prop];
+                }
             }
-            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;
+        return obj;
     }
-    /**
-     * 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);
+    static array(arrayParams) {
+        return new ArraySchema(arrayParams, arrayParams.items);
     }
-    /**
-     * 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);
+    static object(objectParams) {
+        return new ObjectSchema(objectParams, objectParams.properties, objectParams.optionalProperties);
     }
-    async countTokens(_request) {
-        throw new AIError(AIErrorCode.REQUEST_ERROR, 'Count Tokens is not yet available for on-device model.');
+    // eslint-disable-next-line id-blacklist
+    static string(stringParams) {
+        return new StringSchema(stringParams);
     }
-    /**
-     * 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;
+    static enumString(stringParams) {
+        return new StringSchema(stringParams, stringParams.enum);
     }
-    /**
-     * 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;
+    static integer(integerParams) {
+        return new IntegerSchema(integerParams);
     }
-    /**
-     * 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;
-        });
+    // eslint-disable-next-line id-blacklist
+    static number(numberParams) {
+        return new NumberSchema(numberParams);
     }
-    /**
-     * 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
-        };
+    // eslint-disable-next-line id-blacklist
+    static boolean(booleanParams) {
+        return new BooleanSchema(booleanParams);
     }
-    /**
-     * 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.`);
+    static anyOf(anyOfParams) {
+        return new AnyOfSchema(anyOfParams);
     }
-    /**
-     * 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'];
-
-/**
- * @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.
- */
-/**
- * Parent class encompassing all Schema types, with static methods that
- * allow building specific Schema types. This class can be converted with
- * `JSON.stringify()` into a JSON string accepted by Vertex AI REST endpoints.
- * (This string conversion is automatically done when calling SDK methods.)
- * @public
- */
-class Schema {
-    constructor(schemaParams) {
-        // TODO(dlarocque): Enforce this with union types
-        if (!schemaParams.type && !schemaParams.anyOf) {
-            throw new AIError(AIErrorCode.INVALID_SCHEMA, "A schema must have either a 'type' or an 'anyOf' array of sub-schemas.");
-        }
-        // eslint-disable-next-line guard-for-in
-        for (const paramKey in schemaParams) {
-            this[paramKey] = schemaParams[paramKey];
-        }
-        // Ensure these are explicitly set to avoid TS errors.
-        this.type = schemaParams.type;
-        this.format = schemaParams.hasOwnProperty('format')
-            ? schemaParams.format
-            : undefined;
-        this.nullable = schemaParams.hasOwnProperty('nullable')
-            ? !!schemaParams.nullable
-            : false;
-    }
-    /**
-     * Defines how this Schema should be serialized as JSON.
-     * See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify#tojson_behavior
-     * @internal
-     */
-    toJSON() {
-        const obj = {
-            type: this.type
-        };
-        for (const prop in this) {
-            if (this.hasOwnProperty(prop) && this[prop] !== undefined) {
-                if (prop !== 'required' || this.type === SchemaType.OBJECT) {
-                    obj[prop] = this[prop];
-                }
-            }
-        }
-        return obj;
-    }
-    static array(arrayParams) {
-        return new ArraySchema(arrayParams, arrayParams.items);
-    }
-    static object(objectParams) {
-        return new ObjectSchema(objectParams, objectParams.properties, objectParams.optionalProperties);
-    }
-    // eslint-disable-next-line id-blacklist
-    static string(stringParams) {
-        return new StringSchema(stringParams);
-    }
-    static enumString(stringParams) {
-        return new StringSchema(stringParams, stringParams.enum);
-    }
-    static integer(integerParams) {
-        return new IntegerSchema(integerParams);
-    }
-    // eslint-disable-next-line id-blacklist
-    static number(numberParams) {
-        return new NumberSchema(numberParams);
-    }
-    // eslint-disable-next-line id-blacklist
-    static boolean(booleanParams) {
-        return new BooleanSchema(booleanParams);
-    }
-    static anyOf(anyOfParams) {
-        return new AnyOfSchema(anyOfParams);
-    }
-}
-/**
- * Schema class for "integer" types.
- * @public
- */
-class IntegerSchema extends Schema {
-    constructor(schemaParams) {
-        super({
-            type: SchemaType.INTEGER,
-            ...schemaParams
-        });
+}
+/**
+ * Schema class for "integer" types.
+ * @public
+ */
+class IntegerSchema extends Schema {
+    constructor(schemaParams) {
+        super({
+            type: SchemaType.INTEGER,
+            ...schemaParams
+        });
     }
 }
 /**
@@ -3022,11 +2739,11 @@ function getGenerativeModel(ai, modelParams, requestOptions) {
     if (!inCloudParams.model) {
         throw new AIError(AIErrorCode.NO_MODEL, `Must provide a model name. Example: getGenerativeModel({ model: 'my-model-name' })`);
     }
-    let chromeAdapter;
-    // Do not initialize a ChromeAdapter if we are not in hybrid mode.
-    if (typeof window !== 'undefined' && hybridParams.mode) {
-        chromeAdapter = new ChromeAdapterImpl(window.LanguageModel, hybridParams.mode, hybridParams.onDeviceParams);
-    }
+    /**
+     * An AIService registered by index.node.ts will not have a
+     * chromeAdapterFactory() method.
+     */
+    const chromeAdapter = ai.chromeAdapterFactory?.(hybridParams.mode, typeof window === 'undefined' ? undefined : window, hybridParams.onDeviceParams);
     return new GenerativeModel(ai, inCloudParams, requestOptions, chromeAdapter);
 }
 /**
@@ -3050,6 +2767,301 @@ function getImagenModel(ai, modelParams, requestOptions) {
     return new ImagenModel(ai, modelParams, requestOptions);
 }
 
+/**
+ * @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.
  *
@@ -3064,7 +3076,7 @@ function factory(container, { instanceIdentifier }) {
     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);
+    return new AIService(app, backend, auth, appCheckProvider, chromeAdapterFactory);
 }
 function registerAI() {
     app._registerComponent(new component.Component(AI_TYPE, factory, "PUBLIC" /* ComponentType.PUBLIC */).setMultipleInstances(true));