@firebase/ai 2.1.0 → 2.2.0-canary.095c098de

package/dist/index.node.mjs

@@ -1,10 +1,10 @@
 import { _isFirebaseServerApp, _getProvider, getApp, _registerComponent, registerVersion } from '@firebase/app';
 import { Component } from '@firebase/component';
-import { FirebaseError, getModularInstance } from '@firebase/util';
+import { FirebaseError, Deferred, getModularInstance } from '@firebase/util';
 import { Logger } from '@firebase/logger';
 
 var name = "@firebase/ai";
-var version = "2.1.0";
+var version = "2.2.0-canary.095c098de";
 
 /**
  * @license
@@ -24,7 +24,7 @@ var version = "2.1.0";
  */
 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';
@@ -289,7 +289,12 @@ const ResponseModality = {
      * Image.
      * @beta
      */
-    IMAGE: 'IMAGE'
+    IMAGE: 'IMAGE',
+    /**
+     * Audio.
+     * @beta
+     */
+    AUDIO: 'AUDIO'
 };
 /**
  * <b>(EXPERIMENTAL)</b>
@@ -302,6 +307,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
@@ -332,6 +364,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. */
@@ -636,9 +670,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;
@@ -653,6 +688,12 @@ class AIService {
     _delete() {
         return Promise.resolve();
     }
+    set options(optionsToSet) {
+        this._options = optionsToSet;
+    }
+    get options() {
+        return this._options;
+    }
 }
 
 /**
@@ -837,7 +878,12 @@ class AIModel {
                 };
             }
             else if (ai.appCheck) {
-                this._apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
+                if (ai.options?.useLimitedUseAppCheckTokens) {
+                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getLimitedUseToken();
+                }
+                else {
+                    this._apiSettings.getAppCheckToken = () => ai.appCheck.getToken();
+                }
             }
             if (ai.auth) {
                 this._apiSettings.getAuthToken = () => ai.auth.getToken();
@@ -946,7 +992,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
@@ -970,6 +1016,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
  */
@@ -1100,6 +1167,28 @@ async function makeRequest(model, task, apiSettings, stream, body, requestOption
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+/**
+ * Check that at least one candidate exists and does not have a bad
+ * finish reason. Warns if multiple candidates exist.
+ */
+function hasValidCandidates(response) {
+    if (response.candidates && response.candidates.length > 0) {
+        if (response.candidates.length > 1) {
+            logger.warn(`This response had ${response.candidates.length} ` +
+                `candidates. Returning text from the first candidate only. ` +
+                `Access response.candidates directly to use the other candidates.`);
+        }
+        if (hadBadFinishReason(response.candidates[0])) {
+            throw new AIError(AIErrorCode.RESPONSE_ERROR, `Response error: ${formatBlockErrorMessage(response)}. Response body stored in error.response`, {
+                response
+            });
+        }
+        return true;
+    }
+    else {
+        return false;
+    }
+}
 /**
  * Creates an EnhancedGenerateContentResponse object that has helper functions and
  * other modifications that improve usability.
@@ -1123,18 +1212,8 @@ function createEnhancedContentResponse(response) {
  */
 function addHelpers(response) {
     response.text = () => {
-        if (response.candidates && response.candidates.length > 0) {
-            if (response.candidates.length > 1) {
-                logger.warn(`This response had ${response.candidates.length} ` +
-                    `candidates. Returning text from the first candidate only. ` +
-                    `Access response.candidates directly to use the other candidates.`);
-            }
-            if (hadBadFinishReason(response.candidates[0])) {
-                throw new AIError(AIErrorCode.RESPONSE_ERROR, `Response error: ${formatBlockErrorMessage(response)}. Response body stored in error.response`, {
-                    response
-                });
-            }
-            return getText(response);
+        if (hasValidCandidates(response)) {
+            return getText(response, part => !part.thought);
         }
         else if (response.promptFeedback) {
             throw new AIError(AIErrorCode.RESPONSE_ERROR, `Text not available. ${formatBlockErrorMessage(response)}`, {
@@ -1143,18 +1222,20 @@ function addHelpers(response) {
         }
         return '';
     };
+    response.thoughtSummary = () => {
+        if (hasValidCandidates(response)) {
+            const result = getText(response, part => !!part.thought);
+            return result === '' ? undefined : result;
+        }
+        else if (response.promptFeedback) {
+            throw new AIError(AIErrorCode.RESPONSE_ERROR, `Thought summary not available. ${formatBlockErrorMessage(response)}`, {
+                response
+            });
+        }
+        return undefined;
+    };
     response.inlineDataParts = () => {
-        if (response.candidates && response.candidates.length > 0) {
-            if (response.candidates.length > 1) {
-                logger.warn(`This response had ${response.candidates.length} ` +
-                    `candidates. Returning data from the first candidate only. ` +
-                    `Access response.candidates directly to use the other candidates.`);
-            }
-            if (hadBadFinishReason(response.candidates[0])) {
-                throw new AIError(AIErrorCode.RESPONSE_ERROR, `Response error: ${formatBlockErrorMessage(response)}. Response body stored in error.response`, {
-                    response
-                });
-            }
+        if (hasValidCandidates(response)) {
             return getInlineDataParts(response);
         }
         else if (response.promptFeedback) {
@@ -1165,17 +1246,7 @@ function addHelpers(response) {
         return undefined;
     };
     response.functionCalls = () => {
-        if (response.candidates && response.candidates.length > 0) {
-            if (response.candidates.length > 1) {
-                logger.warn(`This response had ${response.candidates.length} ` +
-                    `candidates. Returning function calls from the first candidate only. ` +
-                    `Access response.candidates directly to use the other candidates.`);
-            }
-            if (hadBadFinishReason(response.candidates[0])) {
-                throw new AIError(AIErrorCode.RESPONSE_ERROR, `Response error: ${formatBlockErrorMessage(response)}. Response body stored in error.response`, {
-                    response
-                });
-            }
+        if (hasValidCandidates(response)) {
             return getFunctionCalls(response);
         }
         else if (response.promptFeedback) {
@@ -1188,13 +1259,17 @@ function addHelpers(response) {
     return response;
 }
 /**
- * Returns all text found in all parts of first candidate.
+ * Returns all text from the first candidate's parts, filtering by whether
+ * `partFilter()` returns true.
+ *
+ * @param response - The `GenerateContentResponse` from which to extract text.
+ * @param partFilter - Only return `Part`s for which this returns true
  */
-function getText(response) {
+function getText(response, partFilter) {
     const textStrings = [];
     if (response.candidates?.[0].content?.parts) {
         for (const part of response.candidates?.[0].content?.parts) {
-            if (part.text) {
+            if (part.text && partFilter(part)) {
                 textStrings.push(part.text);
             }
         }
@@ -1207,7 +1282,7 @@ function getText(response) {
     }
 }
 /**
- * Returns {@link FunctionCall}s associated with first candidate.
+ * Returns every {@link FunctionCall} associated with first candidate.
  */
 function getFunctionCalls(response) {
     const functionCalls = [];
@@ -1226,7 +1301,7 @@ function getFunctionCalls(response) {
     }
 }
 /**
- * Returns {@link InlineDataPart}s in the first candidate if present.
+ * Returns every {@link InlineDataPart} in the first candidate if present.
  *
  * @internal
  */
@@ -1305,8 +1380,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 };
@@ -1847,7 +1923,8 @@ function createPredictRequestBody(prompt, { gcsURI, imageFormat, addWatermark, n
             addWatermark,
             safetyFilterLevel,
             personGeneration: personFilterLevel,
-            includeRaiReason: true
+            includeRaiReason: true,
+            includeSafetyAttributes: true
         }
     };
     return body;
@@ -1874,12 +1951,14 @@ const VALID_PART_FIELDS = [
     'text',
     'inlineData',
     'functionCall',
-    'functionResponse'
+    'functionResponse',
+    'thought',
+    'thoughtSignature'
 ];
 const VALID_PARTS_PER_ROLE = {
     user: ['text', 'inlineData'],
     function: ['functionResponse'],
-    model: ['text', 'functionCall'],
+    model: ['text', 'functionCall', 'thought', 'thoughtSignature'],
     // System instructions shouldn't be in history anyway.
     system: ['text']
 };
@@ -1901,7 +1980,7 @@ function validateChatHistory(history) {
             throw new AIError(AIErrorCode.INVALID_CONTENT, `Each item should include role field. Got ${role} but valid roles are: ${JSON.stringify(POSSIBLE_ROLES)}`);
         }
         if (!Array.isArray(parts)) {
-            throw new AIError(AIErrorCode.INVALID_CONTENT, `Content should have 'parts' but property with an array of Parts`);
+            throw new AIError(AIErrorCode.INVALID_CONTENT, `Content should have 'parts' property with an array of Parts`);
         }
         if (parts.length === 0) {
             throw new AIError(AIErrorCode.INVALID_CONTENT, `Each Content should have at least one part`);
@@ -1910,7 +1989,9 @@ function validateChatHistory(history) {
             text: 0,
             inlineData: 0,
             functionCall: 0,
-            functionResponse: 0
+            functionResponse: 0,
+            thought: 0,
+            thoughtSignature: 0
         };
         for (const part of parts) {
             for (const key of VALID_PART_FIELDS) {
@@ -2208,6 +2289,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
@@ -2322,17 +2667,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
@@ -2350,261 +2684,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.
-     *
-     * <ol>Encapsulates a few concerns:
-     *   <li>the mode</li>
-     *   <li>API existence</li>
-     *   <li>prompt formatting</li>
-     *   <li>model availability, including triggering download if necessary</li>
-     * </ol>
-     *
-     * <p>Pros: callers needn't be concerned with details of on-device availability.</p>
-     * <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.</p>
-     */
-    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;
+    send(data) {
+        if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'WebSocket is not open.');
         }
-        // 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.
-     *
-     * <p>This is comparable to {@link GenerativeModel.generateContent} for generating content in
-     * Cloud.</p>
-     * @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.
-     *
-     * <p>This is comparable to {@link GenerativeModel.generateContentStream} for generating content in
-     * Cloud.</p>
-     * @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);
+        this.ws.send(data);
     }
-    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;
+    async *listen() {
+        if (!this.ws) {
+            throw new AIError(AIErrorCode.REQUEST_ERROR, 'WebSocket is not connected.');
         }
-        for (const content of request.contents) {
-            if (content.role === 'function') {
-                logger.debug(`"Function" role rejected for on-device inference.`);
-                return false;
+        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();
             }
-            // 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;
+            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;
             }
-        }
-        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.
-     *
-     * <p>Chrome only downloads models as needed. Chrome knows a model is needed when code calls
-     * LanguageModel.create.</p>
-     *
-     * <p>Since Chrome manages the download, the SDK can only avoid redundant download requests by
-     * tracking if a download has previously been requested.</p>
-     */
-    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.
-     *
-     * <p>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.</p>
-     *
-     * <p>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.</p>
-     */
-    async createSession() {
-        if (!this.languageModelProvider) {
-            throw new AIError(AIErrorCode.UNSUPPORTED, 'Chrome AI requested for unsupported browser version.');
+        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;
+                });
+            }
         }
-        const newSession = await this.languageModelProvider.create(this.onDeviceParams.createOptions);
-        if (this.oldSession) {
-            this.oldSession.destroy();
+        // If the loop terminated because isClosed is true, check for any final errors
+        if (errorQueue.length > 0) {
+            const error = errorQueue.shift();
+            throw error;
         }
-        // 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`));
-                }
-            }))
-        };
+    close(code, reason) {
+        return new Promise(resolve => {
+            if (!this.ws) {
+                return resolve();
+            }
+            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);
+            }
+        });
     }
 }
-// Visible for testing
-ChromeAdapterImpl.SUPPORTED_MIME_TYPES = ['image/jpeg', 'image/png'];
 
 /**
  * @license
@@ -2913,6 +3121,364 @@ class ImagenImageFormat {
     }
 }
 
+/**
+ * @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.
+ */
+const SERVER_INPUT_SAMPLE_RATE = 16000;
+const SERVER_OUTPUT_SAMPLE_RATE = 24000;
+const AUDIO_PROCESSOR_NAME = 'audio-processor';
+/**
+ * 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.
+ *
+ * See: https://developer.mozilla.org/en-US/docs/Web/API/AudioWorkletProcessor
+ *
+ * It is defined as a string here so that it can be converted into a `Blob`
+ * and loaded at runtime.
+ */
+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);
+`;
+/**
+ * Encapsulates the core logic of an audio conversation.
+ *
+ * @internal
+ */
+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 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]);
+        };
+    }
+    /**
+     * 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
@@ -2957,14 +3523,20 @@ class ImagenImageFormat {
  *
  * @public
  */
-function getAI(app = getApp(), options = { backend: new GoogleAIBackend() }) {
+function getAI(app = getApp(), options) {
     app = getModularInstance(app);
     // Dependencies
     const AIProvider = _getProvider(app, AI_TYPE);
-    const identifier = encodeInstanceIdentifier(options.backend);
-    return AIProvider.getImmediate({
+    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
@@ -2987,11 +3559,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);
 }
 /**
@@ -3014,6 +3586,25 @@ 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);
+}
 
 /**
  * The Firebase AI Web SDK.
@@ -3038,5 +3629,5 @@ function registerAI() {
 }
 registerAI();
 
-export { AIError, AIErrorCode, AIModel, AnyOfSchema, ArraySchema, Backend, BackendType, BlockReason, BooleanSchema, ChatSession, FinishReason, FunctionCallingMode, GenerativeModel, GoogleAIBackend, HarmBlockMethod, HarmBlockThreshold, HarmCategory, HarmProbability, HarmSeverity, ImagenAspectRatio, ImagenImageFormat, ImagenModel, ImagenPersonFilterLevel, ImagenSafetyFilterLevel, InferenceMode, IntegerSchema, Modality, NumberSchema, ObjectSchema, POSSIBLE_ROLES, ResponseModality, Schema, SchemaType, StringSchema, VertexAIBackend, getAI, getGenerativeModel, getImagenModel };
+export { AIError, AIErrorCode, AIModel, AnyOfSchema, ArraySchema, Backend, BackendType, BlockReason, BooleanSchema, ChatSession, FinishReason, FunctionCallingMode, GenerativeModel, GoogleAIBackend, HarmBlockMethod, HarmBlockThreshold, HarmCategory, HarmProbability, HarmSeverity, ImagenAspectRatio, ImagenImageFormat, ImagenModel, ImagenPersonFilterLevel, ImagenSafetyFilterLevel, InferenceMode, IntegerSchema, LiveGenerativeModel, LiveResponseType, LiveSession, Modality, NumberSchema, ObjectSchema, POSSIBLE_ROLES, ResponseModality, Schema, SchemaType, StringSchema, VertexAIBackend, getAI, getGenerativeModel, getImagenModel, getLiveGenerativeModel, startAudioConversation };
 //# sourceMappingURL=index.node.mjs.map