prompt-api-polyfill 0.1.0

package/README.md

@@ -0,0 +1,228 @@
+# Prompt API Polyfill (Firebase AI Logic backend)
+
+This package provides a browser polyfill for the
+[Prompt API `LanguageModel`](https://github.com/webmachinelearning/prompt-api)
+backed by **Firebase AI Logic**.
+
+When loaded in the browser, it defines a global:
+
+```js
+window.LanguageModel;
+```
+
+so you can use the Prompt API shape even in environments where it is not yet
+natively available.
+
+- Back end: Firebase AI Logic
+- Default model: `gemini-2.5-flash-lite` (configurable via `modelName`)
+
+---
+
+## Installation
+
+Install from npm:
+
+```bash
+npm install prompt-api-polyfill
+```
+
+## Quick start
+
+1. **Create a Firebase project with Generative AI enabled** (see Configuration
+   below).
+2. **Provide your Firebase config** on `window.FIREBASE_CONFIG`.
+3. **Import the polyfill** so it can attach `window.LanguageModel`.
+
+### Example (using a JSON config file)
+
+Create a `.env.json` file (see
+[Configuring `dot_env.json` / `.env.json`](#configuring-dot_envjson--envjson))
+and then use it from a browser entry point:
+
+```html
+<script type="module">
+  import firebaseConfig from './.env.json' with { type: 'json' };
+
+  // Make the config available to the polyfill
+  window.FIREBASE_CONFIG = firebaseConfig;
+
+  // Only load the polyfill if LanguageModel is not available natively
+  if (!('LanguageModel' in window)) {
+    await import('prompt-api-polyfill');
+  }
+
+  const session = await LanguageModel.create();
+  const text = await session.prompt('Say hello from the polyfill!');
+  console.log(text);
+</script>
+```
+
+> **Note**: The polyfill attaches `LanguageModel` to `window` as a side effect.
+> There are no named exports.
+
+### Example based on `index.html` in this repo
+
+The included `index.html` demonstrates the full surface area of the polyfill,
+including:
+
+- `LanguageModel.create()` with options
+- `prompt()` and `promptStreaming()`
+- Multimodal inputs (text, image, audio)
+- `append()` and `measureInputUsage()`
+- Quota handling via `onquotaoverflow`
+- `clone()` and `destroy()`
+
+A simplified version of how it is wired up:
+
+```html
+<script type="module">
+  import firebaseConfig from './.env.json' with { type: 'json' };
+  window.FIREBASE_CONFIG = firebaseConfig;
+
+  // Load the polyfill only when necessary
+  if (!('LanguageModel' in window)) {
+    await import('prompt-api-polyfill');
+  }
+
+  const controller = new AbortController();
+  const session = await LanguageModel.create();
+
+  try {
+    const stream = session.promptStreaming('Write me a very long poem', {
+      signal: controller.signal,
+    });
+
+    for await (const chunk of stream) {
+      console.log(chunk);
+    }
+  } catch (error) {
+    console.error(error);
+  }
+</script>
+```
+
+---
+
+## Configuring `dot_env.json` / `.env.json`
+
+This repo ships with a template file:
+
+```jsonc
+// dot_env.json
+{
+  "apiKey": "",
+  "projectId": "",
+  "appId": "",
+  "modelName": "",
+}
+```
+
+You should treat `dot_env.json` as a **template** and create a real `.env.json`
+that is **not committed** with your secrets.
+
+### 1. Create `.env.json`
+
+Copy the template:
+
+```bash
+cp dot_env.json .env.json
+```
+
+Then open `.env.json` and fill in the values from your Firebase project:
+
+```json
+{
+  "apiKey": "YOUR_FIREBASE_WEB_API_KEY",
+  "projectId": "your-gcp-project-id",
+  "appId": "YOUR_FIREBASE_APP_ID",
+  "modelName": "gemini-2.5-flash-lite"
+}
+```
+
+### 2. Field-by-field explanation
+
+- `apiKey` Your **Firebase Web API key**. You can find this in the Firebase
+  Console under: _Project settings → General → Your apps → Web app_.
+
+- `projectId` The **GCP / Firebase project ID**, e.g. `my-ai-project`.
+
+- `appId` The **Firebase Web app ID**, e.g. `1:1234567890:web:abcdef123456`.
+
+- `modelName` (optional) The Gemini model ID to use. If omitted, the polyfill
+  defaults to:
+
+  ```json
+  "modelName": "gemini-2.5-flash-lite"
+  ```
+
+  You can substitute another supported Gemini model here if desired.
+
+These fields are passed directly to:
+
+- `initializeApp(firebaseConfig)` from Firebase
+- `getAI(app, { backend: new GoogleAIBackend() })` from the Firebase AI SDK
+
+and `modelName` is used to select which Gemini model to call.
+
+> **Important:** Do **not** commit a real `.env.json` with production
+> credentials to source control. Use `dot_env.json` as the committed template
+> and keep `.env.json` local.
+
+### 3. Wiring the config into the polyfill
+
+Once `.env.json` is filled out, you can import it and expose it to the polyfill
+exactly like in `index.html`:
+
+```js
+import firebaseConfig from './.env.json' with { type: 'json' };
+
+window.FIREBASE_CONFIG = firebaseConfig;
+
+if (!('LanguageModel' in window)) {
+  await import('prompt-api-polyfill');
+}
+```
+
+From this point on, `LanguageModel.create()` will use your Firebase
+configuration.
+
+---
+
+## API surface
+
+Once the polyfill is loaded and `window.LanguageModel` is available, you can use
+it as described in the
+[Prompt API documentation](https://developer.chrome.com/docs/ai/prompt-api).
+
+For a complete, end-to-end example, see the `index.html` file in this directory.
+
+---
+
+## Running the demo locally
+
+1. Install dependencies and this package (if using the npm-installed version in
+   another project):
+
+   ```bash
+   npm install
+   ```
+
+2. Copy and fill in your config:
+
+   ```bash
+   cp dot_env.json .env.json
+   # then edit .env.json with your Firebase and model settings
+   ```
+
+3. Serve `index.html`:
+
+   ```bash
+   npm start
+   ```
+
+You should see network requests to the Vertex AI / Firebase AI backend and
+streaming responses logged in the console.
+
+## License
+
+Apache 2.0

package/async-iterator-polyfill.js

@@ -0,0 +1,16 @@
+if (!ReadableStream.prototype[Symbol.asyncIterator]) {
+  ReadableStream.prototype[Symbol.asyncIterator] = async function* () {
+    const reader = this.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+          return;
+        }
+        yield value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  };
+}

package/dot_env.json

@@ -0,0 +1,6 @@
+{
+  "apiKey": "",
+  "projectId": "",
+  "appId": "",
+  "modelName": ""
+}

package/json-schema-converter.js

@@ -0,0 +1,86 @@
+import { Schema } from 'https://esm.run/firebase/ai';
+
+/**
+ * Converts a standard JSON Schema object into a Firebase Vertex AI Schema class instance.
+ * * @param {Object} jsonSchema - The standard JSON Schema object.
+ * @returns {Schema} - The Firebase Vertex AI Schema instance.
+ */
+export function convertJsonSchemaToVertexSchema(jsonSchema) {
+  if (!jsonSchema) return undefined;
+
+  // Extract common base parameters supported by all Schema types
+  const baseParams = {
+    description: jsonSchema.description,
+    nullable: jsonSchema.nullable || false,
+    format: jsonSchema.format,
+  };
+
+  // Handle "type": ["string", "null"] pattern common in JSON Schema
+  if (Array.isArray(jsonSchema.type) && jsonSchema.type.includes('null')) {
+    baseParams.nullable = true;
+    jsonSchema.type = jsonSchema.type.find((t) => t !== 'null');
+  }
+
+  // SWITCH based on schema type
+  switch (jsonSchema.type) {
+    case 'string':
+      // Check for Enums
+      if (jsonSchema.enum && Array.isArray(jsonSchema.enum)) {
+        return Schema.enumString({
+          ...baseParams,
+          enum: jsonSchema.enum,
+        });
+      }
+      return Schema.string(baseParams);
+
+    case 'number':
+      return Schema.number(baseParams);
+
+    case 'integer':
+      return Schema.integer(baseParams);
+
+    case 'boolean':
+      return Schema.boolean(baseParams);
+
+    case 'array':
+      return Schema.array({
+        ...baseParams,
+        // Recursively convert the 'items' schema
+        items: convertJsonSchemaToVertexSchema(jsonSchema.items),
+      });
+
+    case 'object':
+      const properties = {};
+      const allPropertyKeys = jsonSchema.properties
+        ? Object.keys(jsonSchema.properties)
+        : [];
+
+      // Recursively convert each property
+      allPropertyKeys.forEach((key) => {
+        properties[key] = convertJsonSchemaToVertexSchema(
+          jsonSchema.properties[key]
+        );
+      });
+
+      // Calculate optionalProperties
+      // JSON Schema uses "required" (allowlist), Vertex SDK uses "optionalProperties" (blocklist)
+      const required = jsonSchema.required || [];
+      const optionalProperties = allPropertyKeys.filter(
+        (key) => !required.includes(key)
+      );
+
+      return Schema.object({
+        ...baseParams,
+        properties: properties,
+        optionalProperties: optionalProperties,
+      });
+
+    default:
+      // Fallback for unknown types or complex types not fully supported (like oneOf)
+      // defaulting to string usually prevents crashes, but use with caution.
+      console.warn(
+        `Unsupported type: ${jsonSchema.type}, defaulting to string.`
+      );
+      return Schema.string(baseParams);
+  }
+}

package/multimodal-converter.js

@@ -0,0 +1,195 @@
+export default class MultimodalConverter {
+  static async convert(type, value) {
+    if (type === 'image') return this.processImage(value);
+    if (type === 'audio') return this.processAudio(value);
+    throw new DOMException(
+      `Unsupported media type: ${type}`,
+      'NotSupportedError'
+    );
+  }
+
+  static async processImage(source) {
+    // Blob
+    if (source instanceof Blob) {
+      return this.blobToInlineData(source);
+    }
+
+    // BufferSource (ArrayBuffer/View) -> Sniff or Default
+    if (ArrayBuffer.isView(source) || source instanceof ArrayBuffer) {
+      const buffer = source instanceof ArrayBuffer ? source : source.buffer;
+      const base64 = this.arrayBufferToBase64(buffer);
+      // Basic sniffing for PNG/JPEG magic bytes
+      const u8 = new Uint8Array(buffer);
+      let mimeType = 'image/png'; // Default
+      if (u8[0] === 0xff && u8[1] === 0xd8) mimeType = 'image/jpeg';
+      else if (u8[0] === 0x89 && u8[1] === 0x50) mimeType = 'image/png';
+
+      return { inlineData: { data: base64, mimeType } };
+    }
+
+    // ImageBitmapSource (Canvas, Image, VideoFrame, etc.)
+    // We draw to a canvas to standardize to PNG
+    return this.canvasSourceToInlineData(source);
+  }
+
+  static async processAudio(source) {
+    // Blob
+    if (source instanceof Blob) {
+      return this.blobToInlineData(source);
+    }
+
+    // AudioBuffer -> WAV
+    if (source instanceof AudioBuffer) {
+      const wavBuffer = this.audioBufferToWav(source);
+      const base64 = this.arrayBufferToBase64(wavBuffer);
+      return { inlineData: { data: base64, mimeType: 'audio/wav' } };
+    }
+
+    // BufferSource -> Assume it's already an audio file (mp3/wav)
+    if (ArrayBuffer.isView(source) || source instanceof ArrayBuffer) {
+      const buffer = source instanceof ArrayBuffer ? source : source.buffer;
+      return {
+        inlineData: {
+          data: this.arrayBufferToBase64(buffer),
+          mimeType: 'audio/wav', // Fallback assumption
+        },
+      };
+    }
+
+    throw new DOMException('Unsupported audio source', 'NotSupportedError');
+  }
+
+  // Low Level Converters
+
+  static blobToInlineData(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        if (reader.error) reject(reader.error);
+        else
+          resolve({
+            inlineData: {
+              data: reader.result.split(',')[1],
+              mimeType: blob.type,
+            },
+          });
+      };
+      reader.readAsDataURL(blob);
+    });
+  }
+
+  static canvasSourceToInlineData(source) {
+    const canvas = document.createElement('canvas');
+    const w = source.naturalWidth || source.videoWidth || source.width;
+    const h = source.naturalHeight || source.videoHeight || source.height;
+
+    canvas.width = w;
+    canvas.height = h;
+
+    const ctx = canvas.getContext('2d');
+    ctx.drawImage(source, 0, 0);
+
+    const dataUrl = canvas.toDataURL('image/png');
+    return {
+      inlineData: {
+        data: dataUrl.split(',')[1],
+        mimeType: 'image/png',
+      },
+    };
+  }
+
+  static arrayBufferToBase64(buffer) {
+    let binary = '';
+    const bytes = new Uint8Array(buffer);
+    const len = bytes.byteLength;
+    for (let i = 0; i < len; i++) {
+      binary += String.fromCharCode(bytes[i]);
+    }
+    return window.btoa(binary);
+  }
+
+  // Simple WAV Encoder for AudioBuffer
+  static audioBufferToWav(buffer) {
+    const numChannels = buffer.numberOfChannels;
+    const sampleRate = buffer.sampleRate;
+    const format = 1; // PCM
+    const bitDepth = 16;
+
+    let result;
+    if (numChannels === 2) {
+      result = this.interleave(
+        buffer.getChannelData(0),
+        buffer.getChannelData(1)
+      );
+    } else {
+      result = buffer.getChannelData(0);
+    }
+
+    return this.encodeWAV(result, format, sampleRate, numChannels, bitDepth);
+  }
+
+  static interleave(inputL, inputR) {
+    const length = inputL.length + inputR.length;
+    const result = new Float32Array(length);
+    let index = 0;
+    let inputIndex = 0;
+    while (index < length) {
+      result[index++] = inputL[inputIndex];
+      result[index++] = inputR[inputIndex];
+      inputIndex++;
+    }
+    return result;
+  }
+
+  static encodeWAV(samples, format, sampleRate, numChannels, bitDepth) {
+    const bytesPerSample = bitDepth / 8;
+    const blockAlign = numChannels * bytesPerSample;
+
+    const buffer = new ArrayBuffer(44 + samples.length * bytesPerSample);
+    const view = new DataView(buffer);
+
+    /* RIFF identifier */
+    this.writeString(view, 0, 'RIFF');
+    /* RIFF chunk length */
+    view.setUint32(4, 36 + samples.length * bytesPerSample, true);
+    /* RIFF type */
+    this.writeString(view, 8, 'WAVE');
+    /* format chunk identifier */
+    this.writeString(view, 12, 'fmt ');
+    /* format chunk length */
+    view.setUint32(16, 16, true);
+    /* sample format (raw) */
+    view.setUint16(20, format, true);
+    /* channel count */
+    view.setUint16(22, numChannels, true);
+    /* sample rate */
+    view.setUint32(24, sampleRate, true);
+    /* byte rate (sample rate * block align) */
+    view.setUint32(28, sampleRate * blockAlign, true);
+    /* block align (channel count * bytes per sample) */
+    view.setUint16(32, blockAlign, true);
+    /* bits per sample */
+    view.setUint16(34, bitDepth, true);
+    /* data chunk identifier */
+    this.writeString(view, 36, 'data');
+    /* data chunk length */
+    view.setUint32(40, samples.length * bytesPerSample, true);
+
+    this.floatTo16BitPCM(view, 44, samples);
+
+    return buffer;
+  }
+
+  static floatTo16BitPCM(output, offset, input) {
+    for (let i = 0; i < input.length; i++, offset += 2) {
+      const s = Math.max(-1, Math.min(1, input[i]));
+      output.setInt16(offset, s < 0 ? s * 0x8000 : s * 0x7fff, true);
+    }
+  }
+
+  static writeString(view, offset, string) {
+    for (let i = 0; i < string.length; i++) {
+      view.setUint8(offset + i, string.charCodeAt(i));
+    }
+  }
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "prompt-api-polyfill",
+  "version": "0.1.0",
+  "description": "Polyfill for the Prompt API (`LanguageModel`) backed by Firebase AI Logic.",
+  "type": "module",
+  "main": "./prompt-api-polyfill.js",
+  "module": "./prompt-api-polyfill.js",
+  "browser": "./prompt-api-polyfill.js",
+  "exports": {
+    ".": "./prompt-api-polyfill.js"
+  },
+  "files": [
+    "async-iterator-polyfill.js",
+    "json-schema-converter.js",
+    "multimodal-converter.js",
+    "prompt-api-polyfill.js",
+    "dot_env.json"
+  ],
+  "sideEffects": true,
+  "keywords": [
+    "prompt-api",
+    "language-model",
+    "polyfill",
+    "firebase",
+    "web-ai"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/GoogleChromeLabs/web-ai-demos.git",
+    "directory": "prompt-api-polyfill"
+  },
+  "bugs": {
+    "url": "https://github.com/GoogleChromeLabs/web-ai-demos/issues"
+  },
+  "homepage": "https://github.com/GoogleChromeLabs/web-ai-demos/tree/main/prompt-api-polyfill/README.md",
+  "license": "Apache-2.0",
+  "scripts": {
+    "start": "npx http-server"
+  },
+  "devDependencies": {
+    "http-server": "^14.1.1"
+  }
+}

package/prompt-api-polyfill.js

@@ -0,0 +1,548 @@
+/**
+ * Polyfill for the Prompt API (`LanguageModel`)
+ * Backend: Firebase AI Logic
+ * Spec: https://github.com/webmachinelearning/prompt-api/blob/main/README.md
+ *
+ * * Instructions:
+ * 1. Include this script in your HTML type="module".
+ * 2. Define window.FIREBASE_CONFIG with your Firebase configuration object BEFORE importing this.
+ */
+
+import { initializeApp } from 'https://esm.run/firebase/app';
+import {
+  getAI,
+  getGenerativeModel,
+  GoogleAIBackend,
+  InferenceMode,
+} from 'https://esm.run/firebase/ai';
+
+import './async-iterator-polyfill.js'; // Still needed for Safari 26.2.
+import MultimodalConverter from './multimodal-converter.js';
+import { convertJsonSchemaToVertexSchema } from './json-schema-converter.js';
+
+(() => {
+  if ('LanguageModel' in window) {
+    return;
+  }
+
+  const firebaseConfig = window.FIREBASE_CONFIG;
+  if (!firebaseConfig) {
+    console.error(
+      'Firebase Prompt API Polyfill: Missing configuration. Please set window.FIREBASE_CONFIG.'
+    );
+    return;
+  }
+
+  // Initialize Firebase
+  const app = initializeApp(firebaseConfig);
+  const ai = getAI(app, { backend: new GoogleAIBackend() });
+  const MODEL_NAME = firebaseConfig.modelName || 'gemini-2.5-flash-lite';
+
+  // Helper to convert initial History
+  async function convertToFirebaseHistory(prompts) {
+    const history = [];
+    for (const p of prompts) {
+      const role = p.role === 'assistant' ? 'model' : 'user';
+      let parts = [];
+
+      if (Array.isArray(p.content)) {
+        // Mixed content
+        for (const item of p.content) {
+          if (item.type === 'text') {
+            parts.push({ text: item.value || item.text || '' });
+          } else {
+            const part = await MultimodalConverter.convert(
+              item.type,
+              item.value
+            );
+            parts.push(part);
+          }
+        }
+      } else {
+        // Simple string
+        parts.push({ text: p.content });
+      }
+      history.push({ role, parts });
+    }
+    return history;
+  }
+
+  /**
+   * Main LanguageModel Class
+   */
+  class LanguageModel extends EventTarget {
+    #model;
+    #history;
+    #options;
+    #inCloudParams;
+    #destroyed;
+    #inputUsage;
+    #topK;
+    #temperature;
+    #onquotaoverflow;
+
+    constructor(model, initialHistory, options = {}, inCloudParams) {
+      super();
+      this.#model = model;
+      this.#history = initialHistory || [];
+      this.#options = options;
+      this.#inCloudParams = inCloudParams;
+      this.#destroyed = false;
+      this.#inputUsage = 0;
+
+      this.#topK = options.topK;
+      this.#temperature = options.temperature;
+    }
+
+    get inputUsage() {
+      return this.#inputUsage;
+    }
+    get inputQuota() {
+      return 1000000;
+    }
+    get topK() {
+      return this.#topK;
+    }
+    get temperature() {
+      return this.#temperature;
+    }
+
+    get onquotaoverflow() {
+      return this.#onquotaoverflow;
+    }
+
+    set onquotaoverflow(handler) {
+      if (this.#onquotaoverflow)
+        this.removeEventListener('quotaoverflow', this.#onquotaoverflow);
+      this.#onquotaoverflow = handler;
+      if (typeof handler === 'function')
+        this.addEventListener('quotaoverflow', handler);
+    }
+
+    static async availability(options = {}) {
+      await LanguageModel.#validateOptions(options);
+      return 'available';
+    }
+
+    static async #validateOptions(options = {}) {
+      const { maxTemperature, maxTopK } = await LanguageModel.params();
+
+      const hasTemperature = Object.prototype.hasOwnProperty.call(
+        options,
+        'temperature'
+      );
+      const hasTopK = Object.prototype.hasOwnProperty.call(options, 'topK');
+
+      if (hasTemperature !== hasTopK) {
+        throw new DOMException(
+          'Initializing a new session must either specify both topK and temperature, or neither of them.',
+          'NotSupportedError'
+        );
+      }
+
+      // If neither temperature nor topK are provided, nothing to validate.
+      if (!hasTemperature && !hasTopK) {
+        return;
+      }
+
+      const { temperature, topK } = options;
+
+      if (
+        typeof temperature !== 'number' ||
+        Number.isNaN(temperature) ||
+        typeof topK !== 'number' ||
+        Number.isNaN(topK)
+      ) {
+        throw new DOMException(
+          'The provided temperature and topK must be numbers.',
+          'NotSupportedError'
+        );
+      }
+
+      if (temperature < 0 || temperature > maxTemperature || topK > maxTopK) {
+        throw new DOMException(
+          'The provided temperature or topK is outside the supported range.',
+          'NotSupportedError'
+        );
+      }
+    }
+
+    static async params() {
+      return {
+        // Values from https://docs.cloud.google.com/vertex-ai/generative-ai/docs/models/gemini/2-5-flash-lite#:~:text=%2C%20audio/webm-,Parameter%20defaults,-tune.
+        defaultTemperature: 1.0,
+        defaultTopK: 64,
+        maxTemperature: 2.0,
+        maxTopK: 64, // Fixed
+      };
+    }
+
+    static async create(options = {}) {
+      const availability = await LanguageModel.availability(options);
+      // This will be relevant when the implementation is backed by a local
+      // model that needs downloading and simulates the Prompt API's behavior.
+      if (availability === 'downloadable' || availability === 'downloading') {
+        throw new DOMException(
+          'Requires a user gesture when availability is "downloading" or "downloadable".',
+          'NotAllowedError'
+        );
+      }
+      const defaults = {
+        temperature: 1.0,
+        topK: 3,
+      };
+
+      const resolvedOptions = { ...defaults, ...options };
+
+      const inCloudParams = {
+        model: MODEL_NAME,
+        generationConfig: {
+          temperature: resolvedOptions.temperature,
+          topK: resolvedOptions.topK,
+        },
+      };
+
+      let initialHistory = [];
+      let systemInstruction = undefined;
+
+      if (
+        resolvedOptions.initialPrompts &&
+        Array.isArray(resolvedOptions.initialPrompts)
+      ) {
+        const systemPrompts = resolvedOptions.initialPrompts.filter(
+          (p) => p.role === 'system'
+        );
+        const conversationPrompts = resolvedOptions.initialPrompts.filter(
+          (p) => p.role !== 'system'
+        );
+
+        if (systemPrompts.length > 0) {
+          inCloudParams.systemInstruction = systemPrompts
+            .map((p) => p.content)
+            .join('\n');
+        }
+        // Await the conversion of history items (in case of images in history)
+        initialHistory = await convertToFirebaseHistory(conversationPrompts);
+      }
+
+      const model = getGenerativeModel(ai, {
+        mode: InferenceMode.ONLY_IN_CLOUD,
+        inCloudParams,
+      });
+
+      // If a monitor callback is provided, simulate simple downloadprogress events
+      if (typeof resolvedOptions.monitor === 'function') {
+        const monitorTarget = new EventTarget();
+
+        // Let the caller attach listeners
+        try {
+          resolvedOptions.monitor(monitorTarget);
+        } catch (e) {
+          console.error('Error in monitor callback:', e);
+        }
+
+        // Fire two fake downloadprogress events: first with loaded = 0, then loaded = 1
+        try {
+          const startEvent = new ProgressEvent('downloadprogress', {
+            loaded: 0,
+            total: 1,
+          });
+          const endEvent = new ProgressEvent('downloadprogress', {
+            loaded: 1,
+            total: 1,
+          });
+          // The `ProgressEvent`'s `currentTarget`, `srcElement` and `target`
+          // properties are `EventTarget`, not `CreateMonitor`, when using the
+          // polyfill. Hopefully developers won't rely on these properties.
+          monitorTarget.dispatchEvent(startEvent);
+          monitorTarget.dispatchEvent(endEvent);
+        } catch (e) {
+          console.error('Error dispatching downloadprogress events:', e);
+        }
+      }
+
+      return new LanguageModel(
+        model,
+        initialHistory,
+        resolvedOptions,
+        inCloudParams
+      );
+    }
+
+    // Instance Methods
+
+    async clone(options = {}) {
+      if (this.#destroyed)
+        throw new DOMException('Session is destroyed', 'InvalidStateError');
+      // Clone private history
+      const historyCopy = JSON.parse(JSON.stringify(this.#history));
+      return new LanguageModel(
+        this.#model,
+        historyCopy,
+        {
+          ...this.#options,
+          ...options,
+        },
+        this.#inCloudParams
+      );
+    }
+
+    destroy() {
+      this.#destroyed = true;
+      this.#history = null;
+    }
+
+    async prompt(input, options = {}) {
+      if (this.#destroyed)
+        throw new DOMException('Session is destroyed', 'InvalidStateError');
+      if (options.signal?.aborted)
+        throw new DOMException('Aborted', 'AbortError');
+
+      if (options.responseConstraint) {
+        const vertexSchema = convertJsonSchemaToVertexSchema(
+          options.responseConstraint
+        );
+        this.#inCloudParams.generationConfig.responseMimeType =
+          'application/json';
+        this.#inCloudParams.generationConfig.responseSchema = vertexSchema;
+        this.#model = getGenerativeModel(ai, {
+          mode: InferenceMode.ONLY_IN_CLOUD,
+          inCloudParams: this.#inCloudParams,
+        });
+      }
+
+      // Process Input (Async conversion of Blob/Canvas/AudioBuffer)
+      const parts = await this.#processInput(input);
+      const userContent = { role: 'user', parts: parts };
+
+      try {
+        // Estimate usage before request to fire quota events if needed
+        const { totalTokens } = await this.#model.countTokens({
+          contents: [{ role: 'user', parts }],
+        });
+        if (this.#inputUsage + totalTokens > this.inputQuota)
+          this.dispatchEvent(new Event('quotaoverflow'));
+
+        const requestContents = [...this.#history, userContent];
+
+        const result = await this.#model.generateContent({
+          contents: requestContents,
+        });
+
+        // Exact usage update from Backend response
+        if (result.response.usageMetadata?.totalTokenCount) {
+          this.#inputUsage = result.response.usageMetadata.totalTokenCount;
+        }
+
+        const responseText = result.response.text();
+
+        this.#history.push(userContent);
+        this.#history.push({ role: 'model', parts: [{ text: responseText }] });
+
+        return responseText;
+      } catch (error) {
+        console.error('Firebase AI Logic Error:', error);
+        throw error;
+      }
+    }
+
+    promptStreaming(input, options = {}) {
+      if (this.#destroyed)
+        throw new DOMException('Session is destroyed', 'InvalidStateError');
+      if (options.signal?.aborted)
+        throw new DOMException('Aborted', 'AbortError');
+
+      const _this = this; // Capture 'this' to access private fields in callback
+
+      if (options.responseConstraint) {
+        const vertexSchema = convertJsonSchemaToVertexSchema(
+          options.responseConstraint
+        );
+        this.#inCloudParams.generationConfig.responseMimeType =
+          'application/json';
+        this.#inCloudParams.generationConfig.responseSchema = vertexSchema;
+        this.#model = getGenerativeModel(ai, {
+          mode: InferenceMode.ONLY_IN_CLOUD,
+          inCloudParams: this.#inCloudParams,
+        });
+      }
+
+      const signal = options.signal;
+
+      return new ReadableStream({
+        async start(controller) {
+          const abortError = new DOMException('Aborted', 'AbortError');
+
+          // If already aborted before the stream starts, error the stream.
+          if (signal?.aborted) {
+            controller.error(abortError);
+            return;
+          }
+
+          let aborted = false;
+          const onAbort = () => {
+            aborted = true;
+            try {
+              controller.error(abortError);
+            } catch {
+              // Controller might already be closed/errored; ignore.
+            }
+          };
+
+          if (signal) {
+            signal.addEventListener('abort', onAbort);
+          }
+
+          try {
+            // Access private methods/fields via captured _this
+            const parts = await _this.#processInput(input);
+            const userContent = { role: 'user', parts: parts };
+
+            // Estimate usage before request to fire quota events if needed
+            const { totalTokens } = await _this.#model.countTokens({
+              contents: [{ role: 'user', parts }],
+            });
+            if (_this.#inputUsage + totalTokens > this.inputQuota)
+              this.dispatchEvent(new Event('quotaoverflow'));
+
+            const requestContents = [..._this.#history, userContent];
+
+            const result = await _this.#model.generateContentStream({
+              contents: requestContents,
+            });
+
+            let fullResponseText = '';
+
+            for await (const chunk of result.stream) {
+              if (aborted) {
+                // Try to cancel the underlying iterator; ignore any abort-related errors.
+                if (typeof result.stream.return === 'function') {
+                  try {
+                    await result.stream.return();
+                  } catch (e) {
+                    // Ignore cancellation errors (including AbortError).
+                  }
+                }
+                return;
+              }
+              if (chunk.usageMetadata?.totalTokenCount) {
+                _this.#inputUsage += chunk.usageMetadata.totalTokenCount;
+              }
+              const chunkText = chunk.text();
+              fullResponseText += chunkText;
+              controller.enqueue(chunkText);
+            }
+
+            if (!aborted) {
+              _this.#history.push(userContent);
+              _this.#history.push({
+                role: 'model',
+                parts: [{ text: fullResponseText }],
+              });
+
+              controller.close();
+            }
+          } catch (error) {
+            // If we aborted, we've already signaled an AbortError; otherwise surface the error.
+            if (!aborted) {
+              controller.error(error);
+            }
+          } finally {
+            if (signal) {
+              signal.removeEventListener('abort', onAbort);
+            }
+          }
+        },
+      });
+    }
+
+    async append(input, options = {}) {
+      if (this.#destroyed)
+        throw new DOMException('Session is destroyed', 'InvalidStateError');
+      if (options.signal?.aborted)
+        throw new DOMException('Aborted', 'AbortError');
+
+      const parts = await this.#processInput(input);
+      const content = { role: 'user', parts: parts };
+
+      try {
+        // Try to get accurate count first
+        const { totalTokens } = await this.#model.countTokens({
+          contents: [...this.#history, content],
+        });
+        this.#inputUsage = totalTokens;
+      } catch {
+        // Do nothing.
+      }
+
+      this.#history.push(content);
+
+      if (this.#inputUsage > this.inputQuota) {
+        this.dispatchEvent(new Event('quotaoverflow'));
+      }
+    }
+
+    async measureInputUsage(input) {
+      if (this.#destroyed)
+        throw new DOMException('Session is destroyed', 'InvalidStateError');
+
+      try {
+        const parts = await this.#processInput(input);
+        const { totalTokens } = await this.#model.countTokens({
+          contents: [{ role: 'user', parts }],
+        });
+        return totalTokens;
+      } catch (e) {
+        // The API can't reject, so just return 0 if we don't know.
+        console.warn(
+          'The underlying API call failed, quota usage (0) is not reported accurately.'
+        );
+        return 0;
+      }
+    }
+
+    // Private Helper to process diverse input types
+    async #processInput(input) {
+      if (typeof input === 'string') {
+        return [{ text: input }];
+      }
+
+      if (Array.isArray(input)) {
+        if (input.length > 0 && input[0].role) {
+          let combinedParts = [];
+          for (const msg of input) {
+            if (typeof msg.content === 'string') {
+              combinedParts.push({ text: msg.content });
+              if (msg.prefix) {
+                console.warn(
+                  "The `prefix` flag isn't supported and was ignored."
+                );
+              }
+            } else if (Array.isArray(msg.content)) {
+              for (const c of msg.content) {
+                if (c.type === 'text') combinedParts.push({ text: c.value });
+                else {
+                  const part = await MultimodalConverter.convert(
+                    c.type,
+                    c.value
+                  );
+                  combinedParts.push(part);
+                }
+              }
+            }
+          }
+          return combinedParts;
+        }
+        return input.map((s) => ({ text: String(s) }));
+      }
+
+      return [{ text: JSON.stringify(input) }];
+    }
+  }
+
+  // Attach to window
+  window.LanguageModel = LanguageModel;
+  console.log(
+    'Polyfill: window.LanguageModel is now backed by Firebase AI Logic.'
+  );
+})();