@firebase/ai 2.1.0-canary.84b8bed35 → 2.1.0-canary.984086b0b

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.84b8bed35";
+var version = "2.1.0-canary.984086b0b";
 
 /**
  * @license
@@ -28,7 +28,7 @@ var version = "2.1.0-canary.84b8bed35";
  */
 const AI_TYPE = 'AI';
 const DEFAULT_LOCATION = 'us-central1';
-const DEFAULT_BASE_URL = 'https://firebasevertexai.googleapis.com';
+const DEFAULT_DOMAIN = 'firebasevertexai.googleapis.com';
 const DEFAULT_API_VERSION = 'v1beta';
 const PACKAGE_VERSION = version;
 const LANGUAGE_TAG = 'gl-js';
@@ -293,7 +293,12 @@ const ResponseModality = {
      * Image.
      * @beta
      */
-    IMAGE: 'IMAGE'
+    IMAGE: 'IMAGE',
+    /**
+     * Audio.
+     * @beta
+     */
+    AUDIO: 'AUDIO'
 };
 /**
  * <b>(EXPERIMENTAL)</b>
@@ -306,6 +311,33 @@ const InferenceMode = {
     'ONLY_IN_CLOUD': 'only_in_cloud'
 };
 
+/**
+ * @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.
+ */
+/**
+ * The types of responses that can be returned by {@link LiveSession.receive}.
+ *
+ * @beta
+ */
+const LiveResponseType = {
+    SERVER_CONTENT: 'serverContent',
+    TOOL_CALL: 'toolCall',
+    TOOL_CALL_CANCELLATION: 'toolCallCancellation'
+};
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -336,6 +368,8 @@ const AIErrorCode = {
     RESPONSE_ERROR: 'response-error',
     /** An error occurred while performing a fetch. */
     FETCH_ERROR: 'fetch-error',
+    /** An error occurred because an operation was attempted on a closed session. */
+    SESSION_CLOSED: 'session-closed',
     /** An error associated with a Content object.  */
     INVALID_CONTENT: 'invalid-content',
     /** An error due to the Firebase API not being enabled in the Console. */
@@ -640,9 +674,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;
@@ -961,7 +996,7 @@ class RequestUrl {
         return url.toString();
     }
     get baseUrl() {
-        return this.requestOptions?.baseUrl || DEFAULT_BASE_URL;
+        return this.requestOptions?.baseUrl || `https://${DEFAULT_DOMAIN}`;
     }
     get apiVersion() {
         return DEFAULT_API_VERSION; // TODO: allow user-set options if that feature becomes available
@@ -985,6 +1020,27 @@ class RequestUrl {
         return params;
     }
 }
+class WebSocketUrl {
+    constructor(apiSettings) {
+        this.apiSettings = apiSettings;
+    }
+    toString() {
+        const url = new URL(`wss://${DEFAULT_DOMAIN}`);
+        url.pathname = this.pathname;
+        const queryParams = new URLSearchParams();
+        queryParams.set('key', this.apiSettings.apiKey);
+        url.search = queryParams.toString();
+        return url.toString();
+    }
+    get pathname() {
+        if (this.apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
+            return 'ws/google.firebase.vertexai.v1beta.GenerativeService/BidiGenerateContent';
+        }
+        else {
+            return `ws/google.firebase.vertexai.v1beta.LlmBidiService/BidiGenerateContent/locations/${this.apiSettings.location}`;
+        }
+    }
+}
 /**
  * Log language and "fire/version" to x-goog-api-client
  */
@@ -1328,6 +1384,7 @@ async function handlePredictResponse(response) {
                 gcsURI: prediction.gcsUri
             });
         }
+        else if (prediction.safetyAttributes) ;
         else {
             throw new AIError(AIErrorCode.RESPONSE_ERROR, `Unexpected element in 'predictions' array in response: '${JSON.stringify(prediction)}'`);
         }
@@ -1870,7 +1927,8 @@ function createPredictRequestBody(prompt, { gcsURI, imageFormat, addWatermark, n
             addWatermark,
             safetyFilterLevel,
             personGeneration: personFilterLevel,
-            includeRaiReason: true
+            includeRaiReason: true,
+            includeSafetyAttributes: true
         }
     };
     return body;
@@ -2235,6 +2293,270 @@ class GenerativeModel extends AIModel {
     }
 }
 
+/**
+ * @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.
+ */
+/**
+ * Represents an active, real-time, bidirectional conversation with the model.
+ *
+ * This class should only be instantiated by calling {@link LiveGenerativeModel.connect}.
+ *
+ * @beta
+ */
+class LiveSession {
+    /**
+     * @internal
+     */
+    constructor(webSocketHandler, serverMessages) {
+        this.webSocketHandler = webSocketHandler;
+        this.serverMessages = serverMessages;
+        /**
+         * Indicates whether this Live session is closed.
+         *
+         * @beta
+         */
+        this.isClosed = false;
+        /**
+         * Indicates whether this Live session is being controlled by an `AudioConversationController`.
+         *
+         * @beta
+         */
+        this.inConversation = false;
+    }
+    /**
+     * Sends content to the server.
+     *
+     * @param request - The message to send to the model.
+     * @param turnComplete - Indicates if the turn is complete. Defaults to false.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    async send(request, turnComplete = true) {
+        if (this.isClosed) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'This LiveSession has been closed and cannot be used.');
+        }
+        const newContent = formatNewContent(request);
+        const message = {
+            clientContent: {
+                turns: [newContent],
+                turnComplete
+            }
+        };
+        this.webSocketHandler.send(JSON.stringify(message));
+    }
+    /**
+     * Sends realtime input to the server.
+     *
+     * @param mediaChunks - The media chunks to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    async sendMediaChunks(mediaChunks) {
+        if (this.isClosed) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'This LiveSession has been closed and cannot be used.');
+        }
+        // The backend does not support sending more than one mediaChunk in one message.
+        // Work around this limitation by sending mediaChunks in separate messages.
+        mediaChunks.forEach(mediaChunk => {
+            const message = {
+                realtimeInput: { mediaChunks: [mediaChunk] }
+            };
+            this.webSocketHandler.send(JSON.stringify(message));
+        });
+    }
+    /**
+     * Sends a stream of {@link GenerativeContentBlob}.
+     *
+     * @param mediaChunkStream - The stream of {@link GenerativeContentBlob} to send.
+     * @throws If this session has been closed.
+     *
+     * @beta
+     */
+    async sendMediaStream(mediaChunkStream) {
+        if (this.isClosed) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'This LiveSession has been closed and cannot be used.');
+        }
+        const reader = mediaChunkStream.getReader();
+        while (true) {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    break;
+                }
+                else if (!value) {
+                    throw new Error('Missing chunk in reader, but reader is not done.');
+                }
+                await this.sendMediaChunks([value]);
+            }
+            catch (e) {
+                // Re-throw any errors that occur during stream consumption or sending.
+                const message = e instanceof Error ? e.message : 'Error processing media stream.';
+                throw new AIError(AIErrorCode.REQUEST_ERROR, message);
+            }
+        }
+    }
+    /**
+     * Yields messages received from the server.
+     * This can only be used by one consumer at a time.
+     *
+     * @returns An `AsyncGenerator` that yields server messages as they arrive.
+     * @throws If the session is already closed, or if we receive a response that we don't support.
+     *
+     * @beta
+     */
+    async *receive() {
+        if (this.isClosed) {
+            throw new AIError(AIErrorCode.SESSION_CLOSED, 'Cannot read from a Live session that is closed. Try starting a new Live session.');
+        }
+        for await (const message of this.serverMessages) {
+            if (message && typeof message === 'object') {
+                if (LiveResponseType.SERVER_CONTENT in message) {
+                    yield {
+                        type: 'serverContent',
+                        ...message
+                            .serverContent
+                    };
+                }
+                else if (LiveResponseType.TOOL_CALL in message) {
+                    yield {
+                        type: 'toolCall',
+                        ...message
+                            .toolCall
+                    };
+                }
+                else if (LiveResponseType.TOOL_CALL_CANCELLATION in message) {
+                    yield {
+                        type: 'toolCallCancellation',
+                        ...message.toolCallCancellation
+                    };
+                }
+                else {
+                    logger.warn(`Received an unknown message type from the server: ${JSON.stringify(message)}`);
+                }
+            }
+            else {
+                logger.warn(`Received an invalid message from the server: ${JSON.stringify(message)}`);
+            }
+        }
+    }
+    /**
+     * Closes this session.
+     * All methods on this session will throw an error once this resolves.
+     *
+     * @beta
+     */
+    async close() {
+        if (!this.isClosed) {
+            this.isClosed = true;
+            await this.webSocketHandler.close(1000, 'Client closed session.');
+        }
+    }
+}
+
+/**
+ * @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 Live generative model APIs. The Live API enables low-latency, two-way multimodal
+ * interactions with Gemini.
+ *
+ * This class should only be instantiated with {@link getLiveGenerativeModel}.
+ *
+ * @beta
+ */
+class LiveGenerativeModel extends AIModel {
+    /**
+     * @internal
+     */
+    constructor(ai, modelParams, 
+    /**
+     * @internal
+     */
+    _webSocketHandler) {
+        super(ai, modelParams.model);
+        this._webSocketHandler = _webSocketHandler;
+        this.generationConfig = modelParams.generationConfig || {};
+        this.tools = modelParams.tools;
+        this.toolConfig = modelParams.toolConfig;
+        this.systemInstruction = formatSystemInstruction(modelParams.systemInstruction);
+    }
+    /**
+     * Starts a {@link LiveSession}.
+     *
+     * @returns A {@link LiveSession}.
+     * @throws If the connection failed to be established with the server.
+     *
+     * @beta
+     */
+    async connect() {
+        const url = new WebSocketUrl(this._apiSettings);
+        await this._webSocketHandler.connect(url.toString());
+        let fullModelPath;
+        if (this._apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
+            fullModelPath = `projects/${this._apiSettings.project}/${this.model}`;
+        }
+        else {
+            fullModelPath = `projects/${this._apiSettings.project}/locations/${this._apiSettings.location}/${this.model}`;
+        }
+        const setupMessage = {
+            setup: {
+                model: fullModelPath,
+                generationConfig: this.generationConfig,
+                tools: this.tools,
+                toolConfig: this.toolConfig,
+                systemInstruction: this.systemInstruction
+            }
+        };
+        try {
+            // Begin listening for server messages, and begin the handshake by sending the 'setupMessage'
+            const serverMessages = this._webSocketHandler.listen();
+            this._webSocketHandler.send(JSON.stringify(setupMessage));
+            // Verify we received the handshake response 'setupComplete'
+            const firstMessage = (await serverMessages.next()).value;
+            if (!firstMessage ||
+                !(typeof firstMessage === 'object') ||
+                !('setupComplete' in firstMessage)) {
+                await this._webSocketHandler.close(1011, 'Handshake failure');
+                throw new AIError(AIErrorCode.RESPONSE_ERROR, 'Server connection handshake failed. The server did not respond with a setupComplete message.');
+            }
+            return new LiveSession(this._webSocketHandler, serverMessages);
+        }
+        catch (e) {
+            // Ensure connection is closed on any setup error
+            await this._webSocketHandler.close();
+            throw e;
+        }
+    }
+}
+
 /**
  * @license
  * Copyright 2025 Google LLC
@@ -2349,17 +2671,6 @@ 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
@@ -2377,263 +2688,135 @@ 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.
+ * A wrapper for the native `WebSocket` available in both Browsers and Node >= 22.
+ *
+ * @internal
  */
-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;
+class WebSocketHandlerImpl {
+    constructor() {
+        if (typeof WebSocket === 'undefined') {
+            throw new AIError(AIErrorCode.UNSUPPORTED, 'The WebSocket API is not available in this environment. ' +
+                'The "Live" feature is not supported here. It is supported in ' +
+                'modern browser windows, Web Workers with WebSocket support, and Node >= 22.');
+        }
+    }
+    connect(url) {
+        return new Promise((resolve, reject) => {
+            this.ws = new WebSocket(url);
+            this.ws.binaryType = 'blob'; // Only important to set in Node
+            this.ws.addEventListener('open', () => resolve(), { once: true });
+            this.ws.addEventListener('error', () => reject(new AIError(AIErrorCode.FETCH_ERROR, `Error event raised on WebSocket`)), { once: true });
+            this.ws.addEventListener('close', (closeEvent) => {
+                if (closeEvent.reason) {
+                    logger.warn(`WebSocket connection closed by server. Reason: '${closeEvent.reason}'`);
+                }
+            });
+        });
     }
-    /**
-     * 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;
+    send(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'WebSocket is not open.');
         }
-        if (this.mode === InferenceMode.ONLY_IN_CLOUD) {
-            logger.debug(`On-device inference unavailable because mode is "only_in_cloud".`);
-            return false;
+        this.ws.send(data);
+    }
+    async *listen() {
+        if (!this.ws) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'WebSocket is not connected.');
         }
-        // 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.');
+        const messageQueue = [];
+        const errorQueue = [];
+        let resolvePromise = null;
+        let isClosed = false;
+        const messageListener = async (event) => {
+            let data;
+            if (event.data instanceof Blob) {
+                data = await event.data.text();
             }
-            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;
+            else if (typeof event.data === 'string') {
+                data = event.data;
+            }
+            else {
+                errorQueue.push(new AIError(AIErrorCode.PARSE_FAILED, `Failed to parse WebSocket response. Expected data to be a Blob or string, but was ${typeof event.data}.`));
+                if (resolvePromise) {
+                    resolvePromise();
+                    resolvePromise = null;
+                }
+                return;
+            }
+            try {
+                const obj = JSON.parse(data);
+                messageQueue.push(obj);
+            }
+            catch (e) {
+                const err = e;
+                errorQueue.push(new AIError(AIErrorCode.PARSE_FAILED, `Error parsing WebSocket message to JSON: ${err.message}`));
+            }
+            if (resolvePromise) {
+                resolvePromise();
+                resolvePromise = null;
+            }
+        };
+        const errorListener = () => {
+            errorQueue.push(new AIError(AIErrorCode.FETCH_ERROR, 'WebSocket connection error.'));
+            if (resolvePromise) {
+                resolvePromise();
+                resolvePromise = null;
+            }
+        };
+        const closeListener = (event) => {
+            if (event.reason) {
+                logger.warn(`WebSocket connection closed by the server with reason: ${event.reason}`);
+            }
+            isClosed = true;
+            if (resolvePromise) {
+                resolvePromise();
+                resolvePromise = null;
+            }
+            // Clean up listeners to prevent memory leaks
+            this.ws?.removeEventListener('message', messageListener);
+            this.ws?.removeEventListener('close', closeListener);
+            this.ws?.removeEventListener('error', errorListener);
+        };
+        this.ws.addEventListener('message', messageListener);
+        this.ws.addEventListener('close', closeListener);
+        this.ws.addEventListener('error', errorListener);
+        while (!isClosed) {
+            if (errorQueue.length > 0) {
+                const error = errorQueue.shift();
+                throw error;
+            }
+            if (messageQueue.length > 0) {
+                yield messageQueue.shift();
+            }
+            else {
+                await new Promise(resolve => {
+                    resolvePromise = resolve;
+                });
             }
-            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;
+        // If the loop terminated because isClosed is true, check for any final errors
+        if (errorQueue.length > 0) {
+            const error = errorQueue.shift();
+            throw error;
         }
-        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;
+    close(code, reason) {
+        return new Promise(resolve => {
+            if (!this.ws) {
+                return resolve();
             }
-            // 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;
-                }
+            this.ws.addEventListener('close', () => resolve(), { once: true });
+            // Calling 'close' during these states results in an error.
+            if (this.ws.readyState === WebSocket.CLOSED ||
+                this.ws.readyState === WebSocket.CONNECTING) {
+                return resolve();
+            }
+            if (this.ws.readyState !== WebSocket.CLOSING) {
+                this.ws.close(code, reason);
             }
-        }
-        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'];
 
 /**
  * @license
@@ -2944,7 +3127,7 @@ class ImagenImageFormat {
 
 /**
  * @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.
@@ -2958,75 +3141,433 @@ class ImagenImageFormat {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const SERVER_INPUT_SAMPLE_RATE = 16000;
+const SERVER_OUTPUT_SAMPLE_RATE = 24000;
+const AUDIO_PROCESSOR_NAME = 'audio-processor';
 /**
- * Returns the default {@link AI} instance that is associated with the provided
- * {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new instance with the
- * default settings.
- *
- * @example
- * ```javascript
- * const ai = getAI(app);
- * ```
- *
- * @example
- * ```javascript
- * // Get an AI instance configured to use the Gemini Developer API (via Google AI).
- * const ai = getAI(app, { backend: new GoogleAIBackend() });
- * ```
+ * The JS for an `AudioWorkletProcessor`.
+ * This processor is responsible for taking raw audio from the microphone,
+ * converting it to the required 16-bit 16kHz PCM, and posting it back to the main thread.
  *
- * @example
- * ```javascript
- * // Get an AI instance configured to use the Vertex AI Gemini API.
- * const ai = getAI(app, { backend: new VertexAIBackend() });
- * ```
- *
- * @param app - The {@link @firebase/app#FirebaseApp} to use.
- * @param options - {@link AIOptions} that configure the AI instance.
- * @returns The default {@link AI} instance for the given {@link @firebase/app#FirebaseApp}.
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletProcessor
  *
- * @public
+ * It is defined as a string here so that it can be converted into a `Blob`
+ * and loaded at runtime.
  */
-function getAI(app$1 = app.getApp(), options) {
-    app$1 = util.getModularInstance(app$1);
-    // Dependencies
-    const AIProvider = app._getProvider(app$1, AI_TYPE);
-    const backend = options?.backend ?? new GoogleAIBackend();
-    const finalOptions = {
-        useLimitedUseAppCheckTokens: options?.useLimitedUseAppCheckTokens ?? false
-    };
-    const identifier = encodeInstanceIdentifier(backend);
-    const aiInstance = AIProvider.getImmediate({
-        identifier
-    });
-    aiInstance.options = finalOptions;
-    return aiInstance;
-}
+const audioProcessorWorkletString = `
+  class AudioProcessor extends AudioWorkletProcessor {
+    constructor(options) {
+      super();
+      this.targetSampleRate = options.processorOptions.targetSampleRate;
+      // 'sampleRate' is a global variable available inside the AudioWorkletGlobalScope,
+      // representing the native sample rate of the AudioContext.
+      this.inputSampleRate = sampleRate;
+    }
+
+    /**
+     * This method is called by the browser's audio engine for each block of audio data.
+     * Input is a single input, with a single channel (input[0][0]).
+     */
+    process(inputs) {
+      const input = inputs[0];
+      if (input && input.length > 0 && input[0].length > 0) {
+        const pcmData = input[0]; // Float32Array of raw audio samples.
+        
+        // Simple linear interpolation for resampling.
+        const resampled = new Float32Array(Math.round(pcmData.length * this.targetSampleRate / this.inputSampleRate));
+        const ratio = pcmData.length / resampled.length;
+        for (let i = 0; i < resampled.length; i++) {
+          resampled[i] = pcmData[Math.floor(i * ratio)];
+        }
+
+        // Convert Float32 (-1, 1) samples to Int16 (-32768, 32767)
+        const resampledInt16 = new Int16Array(resampled.length);
+        for (let i = 0; i < resampled.length; i++) {
+          const sample = Math.max(-1, Math.min(1, resampled[i]));
+          if (sample < 0) {
+            resampledInt16[i] = sample * 32768;
+          } else {
+            resampledInt16[i] = sample * 32767;
+          }
+        }
+        
+        this.port.postMessage(resampledInt16);
+      }
+      // Return true to keep the processor alive and processing the next audio block.
+      return true;
+    }
+  }
+
+  // Register the processor with a name that can be used to instantiate it from the main thread.
+  registerProcessor('${AUDIO_PROCESSOR_NAME}', AudioProcessor);
+`;
 /**
- * Returns a {@link GenerativeModel} class with methods for inference
- * and other functionality.
+ * Encapsulates the core logic of an audio conversation.
  *
- * @public
+ * @internal
  */
-function getGenerativeModel(ai, modelParams, requestOptions) {
-    // Uses the existence of HybridParams.mode to clarify the type of the modelParams input.
-    const hybridParams = modelParams;
-    let inCloudParams;
-    if (hybridParams.mode) {
-        inCloudParams = hybridParams.inCloudParams || {
-            model: DEFAULT_HYBRID_IN_CLOUD_MODEL
+class AudioConversationRunner {
+    constructor(liveSession, options, deps) {
+        this.liveSession = liveSession;
+        this.options = options;
+        this.deps = deps;
+        /** A flag to indicate if the conversation has been stopped. */
+        this.isStopped = false;
+        /** A deferred that contains a promise that is resolved when stop() is called, to unblock the receive loop. */
+        this.stopDeferred = new util.Deferred();
+        /** A FIFO queue of 24kHz, 16-bit PCM audio chunks received from the server. */
+        this.playbackQueue = [];
+        /** Tracks scheduled audio sources. Used to cancel scheduled audio when the model is interrupted. */
+        this.scheduledSources = [];
+        /** A high-precision timeline pointer for scheduling gapless audio playback. */
+        this.nextStartTime = 0;
+        /** A mutex to prevent the playback processing loop from running multiple times concurrently. */
+        this.isPlaybackLoopRunning = false;
+        this.liveSession.inConversation = true;
+        // Start listening for messages from the server.
+        this.receiveLoopPromise = this.runReceiveLoop().finally(() => this.cleanup());
+        // Set up the handler for receiving processed audio data from the worklet.
+        // Message data has been resampled to 16kHz 16-bit PCM.
+        this.deps.workletNode.port.onmessage = event => {
+            if (this.isStopped) {
+                return;
+            }
+            const pcm16 = event.data;
+            const base64 = btoa(String.fromCharCode.apply(null, Array.from(new Uint8Array(pcm16.buffer))));
+            const chunk = {
+                mimeType: 'audio/pcm',
+                data: base64
+            };
+            void this.liveSession.sendMediaChunks([chunk]);
         };
     }
-    else {
-        inCloudParams = modelParams;
-    }
+    /**
+     * Stops the conversation and unblocks the main receive loop.
+     */
+    async stop() {
+        if (this.isStopped) {
+            return;
+        }
+        this.isStopped = true;
+        this.stopDeferred.resolve(); // Unblock the receive loop
+        await this.receiveLoopPromise; // Wait for the loop and cleanup to finish
+    }
+    /**
+     * Cleans up all audio resources (nodes, stream tracks, context) and marks the
+     * session as no longer in a conversation.
+     */
+    cleanup() {
+        this.interruptPlayback(); // Ensure all audio is stopped on final cleanup.
+        this.deps.workletNode.port.onmessage = null;
+        this.deps.workletNode.disconnect();
+        this.deps.sourceNode.disconnect();
+        this.deps.mediaStream.getTracks().forEach(track => track.stop());
+        if (this.deps.audioContext.state !== 'closed') {
+            void this.deps.audioContext.close();
+        }
+        this.liveSession.inConversation = false;
+    }
+    /**
+     * Adds audio data to the queue and ensures the playback loop is running.
+     */
+    enqueueAndPlay(audioData) {
+        this.playbackQueue.push(audioData);
+        // Will no-op if it's already running.
+        void this.processPlaybackQueue();
+    }
+    /**
+     * Stops all current and pending audio playback and clears the queue. This is
+     * called when the server indicates the model's speech was interrupted with
+     * `LiveServerContent.modelTurn.interrupted`.
+     */
+    interruptPlayback() {
+        // Stop all sources that have been scheduled. The onended event will fire for each,
+        // which will clean up the scheduledSources array.
+        [...this.scheduledSources].forEach(source => source.stop(0));
+        // Clear the internal buffer of unprocessed audio chunks.
+        this.playbackQueue.length = 0;
+        // Reset the playback clock to start fresh.
+        this.nextStartTime = this.deps.audioContext.currentTime;
+    }
+    /**
+     * Processes the playback queue in a loop, scheduling each chunk in a gapless sequence.
+     */
+    async processPlaybackQueue() {
+        if (this.isPlaybackLoopRunning) {
+            return;
+        }
+        this.isPlaybackLoopRunning = true;
+        while (this.playbackQueue.length > 0 && !this.isStopped) {
+            const pcmRawBuffer = this.playbackQueue.shift();
+            try {
+                const pcm16 = new Int16Array(pcmRawBuffer);
+                const frameCount = pcm16.length;
+                const audioBuffer = this.deps.audioContext.createBuffer(1, frameCount, SERVER_OUTPUT_SAMPLE_RATE);
+                // Convert 16-bit PCM to 32-bit PCM, required by the Web Audio API.
+                const channelData = audioBuffer.getChannelData(0);
+                for (let i = 0; i < frameCount; i++) {
+                    channelData[i] = pcm16[i] / 32768; // Normalize to Float32 range [-1.0, 1.0]
+                }
+                const source = this.deps.audioContext.createBufferSource();
+                source.buffer = audioBuffer;
+                source.connect(this.deps.audioContext.destination);
+                // Track the source and set up a handler to remove it from tracking when it finishes.
+                this.scheduledSources.push(source);
+                source.onended = () => {
+                    this.scheduledSources = this.scheduledSources.filter(s => s !== source);
+                };
+                // To prevent gaps, schedule the next chunk to start either now (if we're catching up)
+                // or exactly when the previous chunk is scheduled to end.
+                this.nextStartTime = Math.max(this.deps.audioContext.currentTime, this.nextStartTime);
+                source.start(this.nextStartTime);
+                // Update the schedule for the *next* chunk.
+                this.nextStartTime += audioBuffer.duration;
+            }
+            catch (e) {
+                logger.error('Error playing audio:', e);
+            }
+        }
+        this.isPlaybackLoopRunning = false;
+    }
+    /**
+     * The main loop that listens for and processes messages from the server.
+     */
+    async runReceiveLoop() {
+        const messageGenerator = this.liveSession.receive();
+        while (!this.isStopped) {
+            const result = await Promise.race([
+                messageGenerator.next(),
+                this.stopDeferred.promise
+            ]);
+            if (this.isStopped || !result || result.done) {
+                break;
+            }
+            const message = result.value;
+            if (message.type === 'serverContent') {
+                const serverContent = message;
+                if (serverContent.interrupted) {
+                    this.interruptPlayback();
+                }
+                const audioPart = serverContent.modelTurn?.parts.find(part => part.inlineData?.mimeType.startsWith('audio/'));
+                if (audioPart?.inlineData) {
+                    const audioData = Uint8Array.from(atob(audioPart.inlineData.data), c => c.charCodeAt(0)).buffer;
+                    this.enqueueAndPlay(audioData);
+                }
+            }
+            else if (message.type === 'toolCall') {
+                if (!this.options.functionCallingHandler) {
+                    logger.warn('Received tool call message, but StartAudioConversationOptions.functionCallingHandler is undefined. Ignoring tool call.');
+                }
+                else {
+                    try {
+                        const resultPart = await this.options.functionCallingHandler(message.functionCalls);
+                        if (!this.isStopped) {
+                            void this.liveSession.send([resultPart]);
+                        }
+                    }
+                    catch (e) {
+                        throw new AIError(AIErrorCode.ERROR, `Function calling handler failed: ${e.message}`);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Starts a real-time, bidirectional audio conversation with the model. This helper function manages
+ * the complexities of microphone access, audio recording, playback, and interruptions.
+ *
+ * @remarks Important: This function must be called in response to a user gesture
+ * (for example, a button click) to comply with {@link https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy | browser autoplay policies}.
+ *
+ * @example
+ * ```javascript
+ * const liveSession = await model.connect();
+ * let conversationController;
+ *
+ * // This function must be called from within a click handler.
+ * async function startConversation() {
+ *   try {
+ *     conversationController = await startAudioConversation(liveSession);
+ *   } catch (e) {
+ *     // Handle AI-specific errors
+ *     if (e instanceof AIError) {
+ *       console.error("AI Error:", e.message);
+ *     }
+ *     // Handle microphone permission and hardware errors
+ *     else if (e instanceof DOMException) {
+ *       console.error("Microphone Error:", e.message);
+ *     }
+ *     // Handle other unexpected errors
+ *     else {
+ *       console.error("An unexpected error occurred:", e);
+ *     }
+ *   }
+ * }
+ *
+ * // Later, to stop the conversation:
+ * // if (conversationController) {
+ * //   await conversationController.stop();
+ * // }
+ * ```
+ *
+ * @param liveSession - An active {@link LiveSession} instance.
+ * @param options - Configuration options for the audio conversation.
+ * @returns A `Promise` that resolves with an {@link AudioConversationController}.
+ * @throws `AIError` if the environment does not support required Web APIs (`UNSUPPORTED`), if a conversation is already active (`REQUEST_ERROR`), the session is closed (`SESSION_CLOSED`), or if an unexpected initialization error occurs (`ERROR`).
+ * @throws `DOMException` Thrown by `navigator.mediaDevices.getUserMedia()` if issues occur with microphone access, such as permissions being denied (`NotAllowedError`) or no compatible hardware being found (`NotFoundError`). See the {@link https://developer.mozilla.org/en-US/docs/Web/API/MediaDevices/getUserMedia#exceptions | MDN documentation} for a full list of exceptions.
+ *
+ * @beta
+ */
+async function startAudioConversation(liveSession, options = {}) {
+    if (liveSession.isClosed) {
+        throw new AIError(AIErrorCode.SESSION_CLOSED, 'Cannot start audio conversation on a closed LiveSession.');
+    }
+    if (liveSession.inConversation) {
+        throw new AIError(AIErrorCode.REQUEST_ERROR, 'An audio conversation is already in progress for this session.');
+    }
+    // Check for necessary Web API support.
+    if (typeof AudioWorkletNode === 'undefined' ||
+        typeof AudioContext === 'undefined' ||
+        typeof navigator === 'undefined' ||
+        !navigator.mediaDevices) {
+        throw new AIError(AIErrorCode.UNSUPPORTED, 'Audio conversation is not supported in this environment. It requires the Web Audio API and AudioWorklet support.');
+    }
+    let audioContext;
+    try {
+        // 1. Set up the audio context. This must be in response to a user gesture.
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/Web_Audio_API/Best_practices#autoplay_policy
+        audioContext = new AudioContext();
+        if (audioContext.state === 'suspended') {
+            await audioContext.resume();
+        }
+        // 2. Prompt for microphone access and get the media stream.
+        // This can throw a variety of permission or hardware-related errors.
+        const mediaStream = await navigator.mediaDevices.getUserMedia({
+            audio: true
+        });
+        // 3. Load the AudioWorklet processor.
+        // See: https://developer.mozilla.org/en-US/docs/Web/API/AudioWorklet
+        const workletBlob = new Blob([audioProcessorWorkletString], {
+            type: 'application/javascript'
+        });
+        const workletURL = URL.createObjectURL(workletBlob);
+        await audioContext.audioWorklet.addModule(workletURL);
+        // 4. Create the audio graph: Microphone -> Source Node -> Worklet Node
+        const sourceNode = audioContext.createMediaStreamSource(mediaStream);
+        const workletNode = new AudioWorkletNode(audioContext, AUDIO_PROCESSOR_NAME, {
+            processorOptions: { targetSampleRate: SERVER_INPUT_SAMPLE_RATE }
+        });
+        sourceNode.connect(workletNode);
+        // 5. Instantiate and return the runner which manages the conversation.
+        const runner = new AudioConversationRunner(liveSession, options, {
+            audioContext,
+            mediaStream,
+            sourceNode,
+            workletNode
+        });
+        return { stop: () => runner.stop() };
+    }
+    catch (e) {
+        // Ensure the audio context is closed on any setup error.
+        if (audioContext && audioContext.state !== 'closed') {
+            void audioContext.close();
+        }
+        // Re-throw specific, known error types directly. The user may want to handle `DOMException`
+        // errors differently (for example, if permission to access audio device was denied).
+        if (e instanceof AIError || e instanceof DOMException) {
+            throw e;
+        }
+        // Wrap any other unexpected errors in a standard AIError.
+        throw new AIError(AIErrorCode.ERROR, `Failed to initialize audio recording: ${e.message}`);
+    }
+}
+
+/**
+ * @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.
+ */
+/**
+ * Returns the default {@link AI} instance that is associated with the provided
+ * {@link @firebase/app#FirebaseApp}. If no instance exists, initializes a new instance with the
+ * default settings.
+ *
+ * @example
+ * ```javascript
+ * const ai = getAI(app);
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Get an AI instance configured to use the Gemini Developer API (via Google AI).
+ * const ai = getAI(app, { backend: new GoogleAIBackend() });
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Get an AI instance configured to use the Vertex AI Gemini API.
+ * const ai = getAI(app, { backend: new VertexAIBackend() });
+ * ```
+ *
+ * @param app - The {@link @firebase/app#FirebaseApp} to use.
+ * @param options - {@link AIOptions} that configure the AI instance.
+ * @returns The default {@link AI} instance for the given {@link @firebase/app#FirebaseApp}.
+ *
+ * @public
+ */
+function getAI(app$1 = app.getApp(), options) {
+    app$1 = util.getModularInstance(app$1);
+    // Dependencies
+    const AIProvider = app._getProvider(app$1, AI_TYPE);
+    const backend = options?.backend ?? new GoogleAIBackend();
+    const finalOptions = {
+        useLimitedUseAppCheckTokens: options?.useLimitedUseAppCheckTokens ?? false
+    };
+    const identifier = encodeInstanceIdentifier(backend);
+    const aiInstance = AIProvider.getImmediate({
+        identifier
+    });
+    aiInstance.options = finalOptions;
+    return aiInstance;
+}
+/**
+ * Returns a {@link GenerativeModel} class with methods for inference
+ * and other functionality.
+ *
+ * @public
+ */
+function getGenerativeModel(ai, modelParams, requestOptions) {
+    // Uses the existence of HybridParams.mode to clarify the type of the modelParams input.
+    const hybridParams = modelParams;
+    let inCloudParams;
+    if (hybridParams.mode) {
+        inCloudParams = hybridParams.inCloudParams || {
+            model: DEFAULT_HYBRID_IN_CLOUD_MODEL
+        };
+    }
+    else {
+        inCloudParams = modelParams;
+    }
     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);
 }
 /**
@@ -3049,6 +3590,320 @@ function getImagenModel(ai, modelParams, requestOptions) {
     }
     return new ImagenModel(ai, modelParams, requestOptions);
 }
+/**
+ * Returns a {@link LiveGenerativeModel} class for real-time, bidirectional communication.
+ *
+ * The Live API is only supported in modern browser windows and Node >= 22.
+ *
+ * @param ai - An {@link AI} instance.
+ * @param modelParams - Parameters to use when setting up a {@link LiveSession}.
+ * @throws If the `apiKey` or `projectId` fields are missing in your
+ * Firebase config.
+ *
+ * @beta
+ */
+function getLiveGenerativeModel(ai, modelParams) {
+    if (!modelParams.model) {
+        throw new AIError(AIErrorCode.NO_MODEL, `Must provide a model name for getLiveGenerativeModel. Example: getLiveGenerativeModel(ai, { model: 'my-model-name' })`);
+    }
+    const webSocketHandler = new WebSocketHandlerImpl();
+    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.
@@ -3064,7 +3919,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));
@@ -3100,6 +3955,9 @@ exports.ImagenPersonFilterLevel = ImagenPersonFilterLevel;
 exports.ImagenSafetyFilterLevel = ImagenSafetyFilterLevel;
 exports.InferenceMode = InferenceMode;
 exports.IntegerSchema = IntegerSchema;
+exports.LiveGenerativeModel = LiveGenerativeModel;
+exports.LiveResponseType = LiveResponseType;
+exports.LiveSession = LiveSession;
 exports.Modality = Modality;
 exports.NumberSchema = NumberSchema;
 exports.ObjectSchema = ObjectSchema;
@@ -3113,4 +3971,6 @@ exports.factory = factory;
 exports.getAI = getAI;
 exports.getGenerativeModel = getGenerativeModel;
 exports.getImagenModel = getImagenModel;
+exports.getLiveGenerativeModel = getLiveGenerativeModel;
+exports.startAudioConversation = startAudioConversation;
 //# sourceMappingURL=index.cjs.js.map