@firebase/ai 1.2.2-canary.f92069a21 → 1.2.2-eap-ai-hybridinference.c16cbf1a3

package/dist/esm/index.esm2017.js

@@ -5,7 +5,7 @@ import { Logger } from '@firebase/logger';
 import { __asyncGenerator, __await } from 'tslib';
 
 var name = "@firebase/ai";
-var version = "1.2.2-canary.f92069a21";
+var version = "1.2.2-eap-ai-hybridinference.c16cbf1a3";
 
 /**
  * @license
@@ -1624,20 +1624,38 @@ function aggregateResponses(responses) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-async function generateContentStream(apiSettings, model, params, requestOptions) {
+async function generateContentStreamOnCloud(apiSettings, model, params, requestOptions) {
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
-    const response = await makeRequest(model, Task.STREAM_GENERATE_CONTENT, apiSettings, 
+    return makeRequest(model, Task.STREAM_GENERATE_CONTENT, apiSettings, 
     /* stream */ true, JSON.stringify(params), requestOptions);
+}
+async function generateContentStream(apiSettings, model, params, chromeAdapter, requestOptions) {
+    let response;
+    if (await chromeAdapter.isAvailable(params)) {
+        response = await chromeAdapter.generateContentStream(params);
+    }
+    else {
+        response = await generateContentStreamOnCloud(apiSettings, model, params, requestOptions);
+    }
     return processStream(response, apiSettings); // TODO: Map streaming responses
 }
-async function generateContent(apiSettings, model, params, requestOptions) {
+async function generateContentOnCloud(apiSettings, model, params, requestOptions) {
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         params = mapGenerateContentRequest(params);
     }
-    const response = await makeRequest(model, Task.GENERATE_CONTENT, apiSettings, 
+    return makeRequest(model, Task.GENERATE_CONTENT, apiSettings, 
     /* stream */ false, JSON.stringify(params), requestOptions);
+}
+async function generateContent(apiSettings, model, params, chromeAdapter, requestOptions) {
+    let response;
+    if (await chromeAdapter.isAvailable(params)) {
+        response = await chromeAdapter.generateContent(params);
+    }
+    else {
+        response = await generateContentOnCloud(apiSettings, model, params, requestOptions);
+    }
     const generateContentResponse = await processGenerateContentResponse(response, apiSettings);
     const enhancedResponse = createEnhancedContentResponse(generateContentResponse);
     return {
@@ -1894,8 +1912,9 @@ const SILENT_ERROR = 'SILENT_ERROR';
  * @public
  */
 class ChatSession {
-    constructor(apiSettings, model, params, requestOptions) {
+    constructor(apiSettings, model, chromeAdapter, params, requestOptions) {
         this.model = model;
+        this.chromeAdapter = chromeAdapter;
         this.params = params;
         this.requestOptions = requestOptions;
         this._history = [];
@@ -1934,7 +1953,7 @@ class ChatSession {
         let finalResult = {};
         // Add onto the chain.
         this._sendPromise = this._sendPromise
-            .then(() => generateContent(this._apiSettings, this.model, generateContentRequest, this.requestOptions))
+            .then(() => generateContent(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, this.requestOptions))
             .then(result => {
             var _a, _b;
             if (result.response.candidates &&
@@ -1975,7 +1994,7 @@ class ChatSession {
             systemInstruction: (_e = this.params) === null || _e === void 0 ? void 0 : _e.systemInstruction,
             contents: [...this._history, newContent]
         };
-        const streamPromise = generateContentStream(this._apiSettings, this.model, generateContentRequest, this.requestOptions);
+        const streamPromise = generateContentStream(this._apiSettings, this.model, generateContentRequest, this.chromeAdapter, this.requestOptions);
         // Add onto the chain.
         this._sendPromise = this._sendPromise
             .then(() => streamPromise)
@@ -2032,7 +2051,7 @@ class ChatSession {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-async function countTokens(apiSettings, model, params, requestOptions) {
+async function countTokensOnCloud(apiSettings, model, params, requestOptions) {
     let body = '';
     if (apiSettings.backend.backendType === BackendType.GOOGLE_AI) {
         const mappedParams = mapCountTokensRequest(params, model);
@@ -2044,6 +2063,12 @@ async function countTokens(apiSettings, model, params, requestOptions) {
     const response = await makeRequest(model, Task.COUNT_TOKENS, apiSettings, false, body, requestOptions);
     return response.json();
 }
+async function countTokens(apiSettings, model, params, chromeAdapter, requestOptions) {
+    if (await chromeAdapter.isAvailable(params)) {
+        return (await chromeAdapter.countTokens(params)).json();
+    }
+    return countTokensOnCloud(apiSettings, model, params, requestOptions);
+}
 
 /**
  * @license
@@ -2066,8 +2091,9 @@ async function countTokens(apiSettings, model, params, requestOptions) {
  * @public
  */
 class GenerativeModel extends AIModel {
-    constructor(ai, modelParams, requestOptions) {
+    constructor(ai, modelParams, chromeAdapter, requestOptions) {
         super(ai, modelParams.model);
+        this.chromeAdapter = chromeAdapter;
         this.generationConfig = modelParams.generationConfig || {};
         this.safetySettings = modelParams.safetySettings || [];
         this.tools = modelParams.tools;
@@ -2081,7 +2107,7 @@ class GenerativeModel extends AIModel {
      */
     async generateContent(request) {
         const formattedParams = formatGenerateContentInput(request);
-        return generateContent(this._apiSettings, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction }, formattedParams), this.requestOptions);
+        return generateContent(this._apiSettings, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction }, formattedParams), this.chromeAdapter, this.requestOptions);
     }
     /**
      * Makes a single streaming call to the model
@@ -2091,23 +2117,27 @@ class GenerativeModel extends AIModel {
      */
     async generateContentStream(request) {
         const formattedParams = formatGenerateContentInput(request);
-        return generateContentStream(this._apiSettings, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction }, formattedParams), this.requestOptions);
+        return generateContentStream(this._apiSettings, this.model, Object.assign({ generationConfig: this.generationConfig, safetySettings: this.safetySettings, tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction }, formattedParams), this.chromeAdapter, this.requestOptions);
     }
     /**
      * Gets a new {@link ChatSession} instance which can be used for
      * multi-turn chats.
      */
     startChat(startChatParams) {
-        return new ChatSession(this._apiSettings, this.model, Object.assign({ tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, generationConfig: this.generationConfig, safetySettings: this.safetySettings }, startChatParams), this.requestOptions);
+        return new ChatSession(this._apiSettings, this.model, this.chromeAdapter, Object.assign({ tools: this.tools, toolConfig: this.toolConfig, systemInstruction: this.systemInstruction, generationConfig: this.generationConfig, safetySettings: this.safetySettings }, startChatParams), this.requestOptions);
     }
     /**
      * Counts the tokens in the provided request.
      */
     async countTokens(request) {
         const formattedParams = formatGenerateContentInput(request);
-        return countTokens(this._apiSettings, this.model, formattedParams);
+        return countTokens(this._apiSettings, this.model, formattedParams, this.chromeAdapter);
     }
 }
+/**
+ * Defines the name of the default in-cloud model to use for hybrid inference.
+ */
+GenerativeModel.DEFAULT_HYBRID_IN_CLOUD_MODEL = 'gemini-2.0-flash-lite';
 
 /**
  * @license
@@ -2216,6 +2246,278 @@ class ImagenModel 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.
+ */
+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 is possible.
+ */
+class ChromeAdapter {
+    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.
+     *
+     * <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 === '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 === 'only_on_device') {
+            return true;
+        }
+        // Applies prefer_on_device logic.
+        if (availability !== Availability.available) {
+            logger.debug(`On-device inference unavailable because availability is "${availability}".`);
+            return false;
+        }
+        if (!ChromeAdapter.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 Vertex {@link GenerateContentRequest}
+     * @returns {@link Response}, so we can reuse common response formatting.
+     */
+    async generateContent(request) {
+        const session = await this.createSession();
+        // TODO: support multiple content objects when Chrome supports
+        // sequence<LanguageModelMessage>
+        const contents = await Promise.all(request.contents[0].parts.map(ChromeAdapter.toLanguageModelMessageContent));
+        const text = await session.prompt(contents, this.onDeviceParams.promptOptions);
+        return ChromeAdapter.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 Vertex {@link GenerateContentRequest}
+     * @returns {@link Response}, so we can reuse common response formatting.
+     */
+    async generateContentStream(request) {
+        const session = await this.createSession();
+        // TODO: support multiple content objects when Chrome supports
+        // sequence<LanguageModelMessage>
+        const contents = await Promise.all(request.contents[0].parts.map(ChromeAdapter.toLanguageModelMessageContent));
+        const stream = await session.promptStreaming(contents, this.onDeviceParams.promptOptions);
+        return ChromeAdapter.toStreamResponse(stream);
+    }
+    async countTokens(_request) {
+        throw new AIError("request-error" /* 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) {
+            // Returns false if the request contains multiple roles, eg a chat history.
+            // TODO: remove this guard once LanguageModelMessage is supported.
+            if (content.role !== 'user') {
+                logger.debug(`Non-user role "${content.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 &&
+                    ChromeAdapter.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() {
+        var _a;
+        const availability = await ((_a = this.languageModelProvider) === null || _a === void 0 ? void 0 : _a.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() {
+        var _a;
+        if (this.isDownloading) {
+            return;
+        }
+        this.isDownloading = true;
+        this.downloadPromise = (_a = this.languageModelProvider) === null || _a === void 0 ? void 0 : _a.create(this.onDeviceParams.createOptions).then(() => {
+            this.isDownloading = false;
+        });
+    }
+    /**
+     * Converts a Vertex Part object to a Chrome LanguageModelMessageContent object.
+     */
+    static async toLanguageModelMessageContent(part) {
+        if (part.text) {
+            return {
+                type: 'text',
+                content: 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',
+                content: imageBitmap
+            };
+        }
+        // Assumes contents have been verified to contain only a single TextPart.
+        // TODO: support other input types
+        throw new Error('Not yet implemented');
+    }
+    /**
+     * Abstracts Chrome session creation.
+     *
+     * <p>Chrome uses a multi-turn session for all inference. Vertex uses single-turn for all
+     * inference. To map the Vertex 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("request-error" /* AIErrorCode.REQUEST_ERROR */, '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 Vertex.
+     */
+    static toResponse(text) {
+        return {
+            json: async () => ({
+                candidates: [
+                    {
+                        content: {
+                            parts: [{ text }]
+                        }
+                    }
+                ]
+            })
+        };
+    }
+    /**
+     * Formats string stream returned by Chrome as SSE returned by Vertex.
+     */
+    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
+ChromeAdapter.SUPPORTED_MIME_TYPES = ['image/jpeg', 'image/png'];
+
 /**
  * @license
  * Copyright 2024 Google LLC
@@ -2571,10 +2873,21 @@ function getAI(app = getApp(), options = { backend: new GoogleAIBackend() }) {
  * @public
  */
 function getGenerativeModel(ai, modelParams, requestOptions) {
-    if (!modelParams.model) {
+    // 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: GenerativeModel.DEFAULT_HYBRID_IN_CLOUD_MODEL
+        };
+    }
+    else {
+        inCloudParams = modelParams;
+    }
+    if (!inCloudParams.model) {
         throw new AIError("no-model" /* AIErrorCode.NO_MODEL */, `Must provide a model name. Example: getGenerativeModel({ model: 'my-model-name' })`);
     }
-    return new GenerativeModel(ai, modelParams, requestOptions);
+    return new GenerativeModel(ai, inCloudParams, new ChromeAdapter(window.LanguageModel, hybridParams.mode, hybridParams.onDeviceParams), requestOptions);
 }
 /**
  * Returns an {@link ImagenModel} class with methods for using Imagen.