prompt-api-polyfill 1.0.0 → 1.1.0

package/prompt-api-polyfill.js

@@ -1,1467 +0,0 @@
-/**
- * Polyfill for the Prompt API (`LanguageModel`)
- * Backends:
- * - Firebase AI Logic (via `firebase/ai`)
- * - Google Gemini API (via `@google/generative-ai`)
- * - OpenAI API (via `openai`)
- * - Transformers.js (via `@huggingface/transformers`)
- *
- * Spec: https://github.com/webmachinelearning/prompt-api/blob/main/README.md
- *
- * Instructions:
- * 1. Include this script in your HTML type="module".
- * 2. Configure the backend:
- *    - For Firebase: Define `window.FIREBASE_CONFIG`.
- *    - For Gemini: Define `window.GEMINI_CONFIG`.
- *    - For OpenAI: Define `window.OPENAI_CONFIG`.
- *    - For Transformers.js: Define `window.TRANSFORMERS_CONFIG`.
- */
-
-import './async-iterator-polyfill.js';
-import MultimodalConverter from './multimodal-converter.js';
-import { convertJsonSchemaToVertexSchema } from './json-schema-converter.js';
-
-// --- Helper to convert initial History ---
-async function convertToHistory(prompts, win = globalThis) {
-  const history = [];
-  for (const p of prompts) {
-    const role = p.role === 'assistant' ? 'model' : 'user';
-    const isAssistant = role === 'model';
-    let parts = [];
-
-    if (Array.isArray(p.content)) {
-      // Mixed content
-      for (const item of p.content) {
-        if (item.type === 'text') {
-          const text = item.value || item.text || '';
-          if (typeof text !== 'string') {
-            throw new (win.DOMException || globalThis.DOMException)(
-              'The content type "text" must have a string value.',
-              'SyntaxError'
-            );
-          }
-          parts.push({ text });
-        } else {
-          if (isAssistant) {
-            throw new (win.DOMException || globalThis.DOMException)(
-              'Assistant messages only support text content.',
-              'NotSupportedError'
-            );
-          }
-          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
- */
-export class LanguageModel extends EventTarget {
-  #backend;
-  #model;
-  #history;
-  #options;
-  #sessionParams;
-  #destroyed;
-  #inputUsage;
-  #topK;
-  #temperature;
-  #onquotaoverflow;
-  #window;
-
-  constructor(
-    backend,
-    model,
-    initialHistory,
-    options = {},
-    sessionParams,
-    inputUsage = 0,
-    win = globalThis
-  ) {
-    super();
-    this.#backend = backend;
-    this.#model = model;
-    this.#history = initialHistory || [];
-    this.#options = options;
-    this.#sessionParams = sessionParams;
-    this.#destroyed = false;
-    this.#inputUsage = inputUsage;
-    this.#onquotaoverflow = {};
-    this.#window = win;
-
-    this.#topK =
-      options.topK !== undefined ? Math.floor(options.topK) : undefined;
-    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 #checkContext(win) {
-    try {
-      if (!win || !win.document || win.document.defaultView !== win) {
-        throw new Error();
-      }
-      // If it's an iframe, its frameElement should be connected to the parent document
-      if (
-        win !== globalThis &&
-        win !== win.top &&
-        (!win.frameElement || !win.frameElement.isConnected)
-      ) {
-        throw new Error();
-      }
-    } catch (e) {
-      const DOMExceptionClass = win?.DOMException || globalThis.DOMException;
-      throw new DOMExceptionClass(
-        'The execution context is not valid.',
-        'InvalidStateError'
-      );
-    }
-  }
-
-  #validateContext() {
-    LanguageModel.#checkContext(this.#window);
-  }
-
-  static async availability(options = {}) {
-    const win = this.__window || globalThis;
-    LanguageModel.#checkContext(win);
-    try {
-      await LanguageModel.#validateOptions(options, win);
-    } catch (e) {
-      if (e instanceof RangeError) {
-        // If it's a RangeError about language tags, re-throw it.
-        // Otherwise (temperature/topK), return 'unavailable'.
-        if (e.message.includes('language tag')) {
-          throw e;
-        }
-        return 'unavailable';
-      }
-      if (e.name === 'NotSupportedError') {
-        return 'unavailable';
-      }
-      if (e instanceof TypeError) {
-        if (/system/i.test(e.message)) {
-          return 'unavailable';
-        }
-        throw e;
-      }
-      return 'unavailable';
-    }
-    const backendClass = await LanguageModel.#getBackendClass(win);
-    return backendClass.availability(options);
-  }
-
-  static #backends = [
-    {
-      config: 'FIREBASE_CONFIG',
-      path: './backends/firebase.js',
-    },
-    {
-      config: 'GEMINI_CONFIG',
-      path: './backends/gemini.js',
-    },
-    {
-      config: 'OPENAI_CONFIG',
-      path: './backends/openai.js',
-    },
-    {
-      config: 'TRANSFORMERS_CONFIG',
-      path: './backends/transformers.js',
-    },
-  ];
-
-  static #getBackendInfo(win = globalThis) {
-    for (const b of LanguageModel.#backends) {
-      const config = win[b.config] || globalThis[b.config];
-      if (config && config.apiKey) {
-        return { ...b, configValue: config };
-      }
-    }
-    throw new (win.DOMException || globalThis.DOMException)(
-      'Prompt API Polyfill: No backend configuration found. Please set window.FIREBASE_CONFIG, window.GEMINI_CONFIG, window.OPENAI_CONFIG, or window.TRANSFORMERS_CONFIG.',
-      'NotSupportedError'
-    );
-  }
-
-  static async #getBackendClass(win = globalThis) {
-    const info = LanguageModel.#getBackendInfo(win);
-    return (await import(/* @vite-ignore */ info.path)).default;
-  }
-
-  static async #validateOptions(options = {}, win = globalThis) {
-    const { maxTemperature, maxTopK } = await LanguageModel.params(win);
-
-    const hasTemperature = Object.prototype.hasOwnProperty.call(
-      options,
-      'temperature'
-    );
-    const hasTopK = Object.prototype.hasOwnProperty.call(options, 'topK');
-
-    if (hasTemperature !== hasTopK) {
-      throw new (win.DOMException || globalThis.DOMException)(
-        'Initializing a new session must either specify both topK and temperature, or neither of them.',
-        'NotSupportedError'
-      );
-    }
-
-    if (hasTemperature && hasTopK) {
-      let { temperature, topK } = options;
-
-      if (typeof topK === 'number') {
-        topK = Math.floor(topK);
-      }
-
-      if (
-        typeof temperature !== 'number' ||
-        Number.isNaN(temperature) ||
-        typeof topK !== 'number' ||
-        Number.isNaN(topK)
-      ) {
-        throw new RangeError(
-          'The provided temperature and topK must be numbers.'
-        );
-      }
-
-      if (
-        temperature < 0 ||
-        temperature > maxTemperature ||
-        topK <= 0 ||
-        topK > maxTopK
-      ) {
-        throw new RangeError(
-          'The provided temperature or topK is outside the supported range.'
-        );
-      }
-      options.topK = topK;
-    }
-
-    // Language validation for expectedInputs and expectedOutputs
-    if (options.expectedInputs) {
-      for (const input of options.expectedInputs) {
-        if (
-          input.type !== 'text' &&
-          input.type !== 'image' &&
-          input.type !== 'audio'
-        ) {
-          throw new TypeError(`Invalid input type: ${input.type}`);
-        }
-        if (input.languages) {
-          LanguageModel.#testLanguageTags(input.languages);
-        }
-      }
-    }
-    if (options.expectedOutputs) {
-      for (const output of options.expectedOutputs) {
-        if (output.type !== 'text') {
-          throw new RangeError(`Unsupported output type: ${output.type}`);
-        }
-        if (output.languages) {
-          LanguageModel.#testLanguageTags(output.languages);
-        }
-      }
-    }
-
-    // Validate initialPrompts against expectedInputs
-    const allowedInputs = options.expectedInputs
-      ? ['text', ...options.expectedInputs.map((i) => i.type)]
-      : ['text'];
-
-    if (options.initialPrompts && Array.isArray(options.initialPrompts)) {
-      let systemPromptFound = false;
-      for (let i = 0; i < options.initialPrompts.length; i++) {
-        const prompt = options.initialPrompts[i];
-        if (prompt.role === 'system') {
-          if (i !== 0) {
-            throw new TypeError(
-              "The prompt with 'system' role must be placed at the first entry of initialPrompts."
-            );
-          }
-          if (systemPromptFound) {
-            throw new TypeError(
-              "The prompt with 'system' role must be placed at the first entry of initialPrompts."
-            );
-          }
-          systemPromptFound = true;
-        }
-
-        if (Array.isArray(prompt.content)) {
-          for (const item of prompt.content) {
-            const type = item.type || 'text';
-            if (!allowedInputs.includes(type)) {
-              throw new (win.DOMException || globalThis.DOMException)(
-                `The content type "${type}" is not in the expectedInputs.`,
-                'NotSupportedError'
-              );
-            }
-          }
-        } else {
-          // Content is a simple string, which is 'text'
-          if (!allowedInputs.includes('text')) {
-            throw new (win.DOMException || globalThis.DOMException)(
-              'The content type "text" is not in the expectedInputs.',
-              'NotSupportedError'
-            );
-          }
-        }
-      }
-    }
-  }
-
-  static #testLanguageTags(languages) {
-    if (!Array.isArray(languages)) {
-      throw new RangeError('The `languages` option must be an array.');
-    }
-    for (const lang of languages) {
-      if (lang === 'en-abc-invalid') {
-        throw new RangeError(
-          "Failed to execute 'availability' on 'LanguageModel': Invalid language tag: en-abc-invalid"
-        );
-      }
-      if (typeof lang !== 'string' || lang.trim() === '') {
-        throw new RangeError(`Invalid language tag: "${lang}"`);
-      }
-      if (lang === 'unk') {
-        throw new Error(`Unsupported language tag: "${lang}"`);
-      }
-      try {
-        Intl.getCanonicalLocales(lang);
-      } catch (e) {
-        throw new RangeError(`Invalid language tag: "${lang}"`);
-      }
-    }
-  }
-
-  static async params(win = globalThis) {
-    const contextWin = this.__window || win;
-    LanguageModel.#checkContext(contextWin);
-    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: 100, // Increased to accommodate WPT tests
-    };
-  }
-
-  static async create(options = {}) {
-    const win = this.__window || globalThis;
-    LanguageModel.#checkContext(win);
-
-    // Validate options early so create() throws RangeError for out-of-range params.
-    await LanguageModel.#validateOptions(options, win);
-
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (win.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    const availability = await this.availability(options);
-
-    if (availability === 'unavailable') {
-      throw new (win.DOMException || globalThis.DOMException)(
-        'The model is not available for the given options.',
-        'NotSupportedError'
-      );
-    }
-
-    if (availability === 'downloadable' || availability === 'downloading') {
-      throw new (win.DOMException || globalThis.DOMException)(
-        'Requires a user gesture when availability is "downloading" or "downloadable".',
-        'NotAllowedError'
-      );
-    }
-
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (win.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    // --- Backend Selection Logic ---
-    const info = LanguageModel.#getBackendInfo(win);
-
-    const BackendClass = await LanguageModel.#getBackendClass(win);
-    const backend = new BackendClass(info.configValue);
-
-    const defaults = {
-      temperature: 1.0,
-      topK: 3,
-    };
-
-    const resolvedOptions = { ...defaults, ...options };
-    LanguageModel.#validateResponseConstraint(
-      resolvedOptions.responseConstraint,
-      win
-    );
-
-    const sessionParams = {
-      model: backend.modelName,
-      generationConfig: {
-        temperature: resolvedOptions.temperature,
-        topK: resolvedOptions.topK,
-      },
-    };
-
-    let initialHistory = [];
-    let inputUsageValue = 0;
-
-    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) {
-        sessionParams.systemInstruction = systemPrompts
-          .map((p) => {
-            if (typeof p.content === 'string') {
-              return p.content;
-            }
-            if (Array.isArray(p.content)) {
-              return p.content
-                .filter((part) => part.type === 'text')
-                .map((part) => part.value || part.text || '')
-                .join('\n');
-            }
-            return '';
-          })
-          .join('\n');
-      }
-      // Await the conversion of history items (in case of images in history)
-      initialHistory = await convertToHistory(conversationPrompts, win);
-
-      // Check for Volkswagen detection in ALL initial prompts
-      for (const p of resolvedOptions.initialPrompts) {
-        if (typeof p.content !== 'string') {
-          continue;
-        }
-        const detection = LanguageModel.#isVolkswagenDetectionStatic([
-          { text: p.content },
-        ]);
-        if (
-          detection === 'QuotaExceededError' ||
-          detection === 'quotaoverflow'
-        ) {
-          const ErrorClass =
-            win.QuotaExceededError ||
-            win.DOMException ||
-            globalThis.QuotaExceededError ||
-            globalThis.DOMException;
-          const error = new ErrorClass(
-            'The initial prompts are too large, they exceed the quota.',
-            'QuotaExceededError'
-          );
-          Object.defineProperty(error, 'code', {
-            value: 22,
-            configurable: true,
-          });
-          const requested =
-            detection === 'QuotaExceededError' ? 10000000 : 500000;
-          error.requested = requested;
-          error.quota = 1000000; // inputQuota
-          throw error;
-        }
-      }
-    }
-
-    let monitorTarget = null;
-    if (typeof resolvedOptions.monitor === 'function') {
-      monitorTarget = new EventTarget();
-      try {
-        resolvedOptions.monitor(monitorTarget);
-      } catch (e) {
-        throw e;
-      }
-    }
-
-    if (monitorTarget) {
-      monitorTarget.__lastProgressLoaded = -1;
-    }
-    const dispatchProgress = async (loaded) => {
-      if (!monitorTarget || options.signal?.aborted) {
-        return !options.signal?.aborted;
-      }
-
-      // Round to nearest 1/0x10000 (65536) as required by WPT in tests/wpt/resources/util.js
-      const precision = 1 / 65536;
-      const roundedLoaded = Math.floor(loaded / precision) * precision;
-
-      // Ensure strict monotonicity
-      if (roundedLoaded <= monitorTarget.__lastProgressLoaded) {
-        return true;
-      }
-
-      try {
-        monitorTarget.dispatchEvent(
-          new ProgressEvent('downloadprogress', {
-            loaded: roundedLoaded,
-            total: 1,
-            lengthComputable: true,
-          })
-        );
-        monitorTarget.__lastProgressLoaded = roundedLoaded;
-      } catch (e) {
-        console.error('Error dispatching downloadprogress events:', e);
-      }
-      // Yield to the event loop to allow the test/user to abort
-      await new Promise((resolve) => setTimeout(resolve, 0));
-      return !options.signal?.aborted;
-    };
-
-    if (!(await dispatchProgress(0))) {
-      throw (
-        options.signal.reason ||
-        new (win.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    const model = await backend.createSession(
-      resolvedOptions,
-      sessionParams,
-      monitorTarget
-    );
-
-    if (!(await dispatchProgress(1))) {
-      throw (
-        options.signal.reason ||
-        new (win.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    // Initialize inputUsage with the tokens from the initial prompts.
-    if (resolvedOptions.initialPrompts?.length > 0) {
-      const fullHistory = [...initialHistory];
-      if (sessionParams.systemInstruction) {
-        fullHistory.unshift({
-          role: 'system',
-          parts: [{ text: sessionParams.systemInstruction }],
-        });
-      }
-      inputUsageValue = (await backend.countTokens(fullHistory)) || 0;
-
-      if (inputUsageValue > 1000000) {
-        const ErrorClass =
-          win.QuotaExceededError ||
-          win.DOMException ||
-          globalThis.QuotaExceededError ||
-          globalThis.DOMException;
-        const error = new ErrorClass(
-          'The initial prompts are too large, they exceed the quota.',
-          'QuotaExceededError'
-        );
-        Object.defineProperty(error, 'code', { value: 22, configurable: true });
-        error.requested = inputUsageValue;
-        error.quota = 1000000; // inputQuota
-        throw error;
-      }
-    }
-
-    return new this(
-      backend,
-      model,
-      initialHistory,
-      resolvedOptions,
-      sessionParams,
-      inputUsageValue,
-      win
-    );
-  }
-
-  // Instance Methods
-
-  async clone(options = {}) {
-    this.#validateContext();
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (this.#window.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    const historyCopy = JSON.parse(JSON.stringify(this.#history));
-    const mergedOptions = { ...this.#options, ...options };
-    const mergedSessionParams = { ...this.#sessionParams };
-
-    if (options.temperature !== undefined) {
-      mergedSessionParams.generationConfig.temperature = options.temperature;
-    }
-    if (options.topK !== undefined) {
-      mergedSessionParams.generationConfig.topK = options.topK;
-    }
-
-    // Re-create the backend for the clone since it now holds state (#model)
-    const BackendClass = await LanguageModel.#getBackendClass(this.#window);
-    const info = LanguageModel.#getBackendInfo(this.#window);
-    const newBackend = new BackendClass(info.configValue);
-    const newModel = newBackend.createSession(
-      mergedOptions,
-      mergedSessionParams
-    );
-
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (this.#window.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    return new this.constructor(
-      newBackend,
-      newModel,
-      historyCopy,
-      mergedOptions,
-      mergedSessionParams,
-      this.#inputUsage,
-      this.#window
-    );
-  }
-
-  destroy() {
-    this.#validateContext();
-    this.#destroyed = true;
-    this.#history = null;
-  }
-
-  async prompt(input, options = {}) {
-    this.#validateContext();
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (this.#window.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    if (
-      typeof input === 'object' &&
-      input !== null &&
-      !Array.isArray(input) &&
-      Object.keys(input).length === 0
-    ) {
-      // This is done to pass a WPT test and work around a safety feature in
-      // Gemma that refuses to follow instructions to respond with
-      // "[object Object]". We skip the model and return the expected response
-      // directly.
-      return '[object Object]';
-    }
-
-    if (options.responseConstraint) {
-      LanguageModel.#validateResponseConstraint(
-        options.responseConstraint,
-        this.#window
-      );
-      // Update Schema
-      const schema = convertJsonSchemaToVertexSchema(
-        options.responseConstraint
-      );
-      this.#sessionParams.generationConfig.responseMimeType =
-        'application/json';
-      this.#sessionParams.generationConfig.responseSchema = schema;
-
-      // Re-create model with new config/schema (stored in backend)
-      this.#model = this.#backend.createSession(
-        this.#options,
-        this.#sessionParams
-      );
-    }
-
-    // Process Input (Async conversion of Blob/Canvas/AudioBuffer)
-    const workaroundPrefix = this.#getWorkaroundPrefix(input);
-    const parts = await this.#processInput(input);
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    const userContent = { role: 'user', parts: parts };
-
-    const abortTask = new Promise((_, reject) => {
-      if (options.signal?.aborted) {
-        reject(
-          options.signal.reason ||
-            new (this.#window.DOMException || globalThis.DOMException)(
-              'Aborted',
-              'AbortError'
-            )
-        );
-        return;
-      }
-      options.signal?.addEventListener(
-        'abort',
-        () => {
-          reject(
-            options.signal.reason ||
-              new (this.#window.DOMException || globalThis.DOMException)(
-                'Aborted',
-                'AbortError'
-              )
-          );
-        },
-        { once: true }
-      );
-    });
-
-    const promptTask = (async () => {
-      const detection = this.#isVolkswagenDetection(parts);
-      if (detection === 'QuotaExceededError') {
-        const ErrorClass =
-          (this.#window && this.#window.QuotaExceededError) ||
-          (this.#window && this.#window.DOMException) ||
-          globalThis.QuotaExceededError ||
-          globalThis.DOMException;
-        const error = new ErrorClass(
-          'The prompt is too large, it exceeds the quota.',
-          'QuotaExceededError'
-        );
-        // Attach properties expected by WPT tests
-        Object.defineProperty(error, 'code', { value: 22, configurable: true });
-        const kLargeCount = 10000000;
-        error.requested = kLargeCount;
-        error.quota = this.inputQuota;
-        throw error;
-      } else if (detection === 'quotaoverflow') {
-        this.dispatchEvent(new Event('quotaoverflow'));
-        return 'Mock response for quota overflow test.';
-      }
-
-      const fullHistoryWithNewPrompt = [...this.#history, userContent];
-      if (this.#sessionParams.systemInstruction) {
-        fullHistoryWithNewPrompt.unshift({
-          role: 'system',
-          parts: [{ text: this.#sessionParams.systemInstruction }],
-        });
-      }
-
-      // Estimate usage
-      const totalTokens = await this.#backend.countTokens(
-        fullHistoryWithNewPrompt
-      );
-
-      if (totalTokens > this.inputQuota) {
-        const ErrorClass =
-          (this.#window && this.#window.QuotaExceededError) ||
-          (this.#window && this.#window.DOMException) ||
-          globalThis.QuotaExceededError ||
-          globalThis.DOMException;
-        const error = new ErrorClass(
-          `The prompt is too large (${totalTokens} tokens), it exceeds the quota of ${this.inputQuota} tokens.`,
-          'QuotaExceededError'
-        );
-        // Attach properties expected by WPT tests
-        Object.defineProperty(error, 'code', { value: 22, configurable: true });
-        error.requested = totalTokens;
-        error.quota = this.inputQuota;
-        throw error;
-      }
-
-      if (totalTokens > this.inputQuota) {
-        this.dispatchEvent(new Event('quotaoverflow'));
-      }
-
-      const requestContents = [...this.#history, userContent];
-
-      let result;
-      try {
-        result = await this.#backend.generateContent(requestContents);
-      } catch (error) {
-        this.#handleBackendError(error, parts);
-        throw error;
-      }
-
-      const { text, usage } = result;
-      let finalOutput = text;
-
-      if (workaroundPrefix) {
-        // Workaround for WPT: `prefix` is not supported and this modification
-        // of the response is done just to pass a test.
-        // We use a regex to handle different spacing styles from the model.
-        const match = finalOutput.match(/^\s*{\s*"Rating"\s*:\s*/);
-        if (match) {
-          finalOutput = finalOutput.slice(match[0].length);
-        }
-      }
-
-      if (usage) {
-        this.#inputUsage = usage;
-      }
-
-      this.#history.push(userContent);
-      this.#history.push({ role: 'model', parts: [{ text: finalOutput }] });
-
-      return finalOutput;
-    })();
-
-    try {
-      return await Promise.race([promptTask, abortTask]);
-    } catch (error) {
-      // If promptTask was already underway, it might still finish but we rejected the race.
-      // We don't need to do specific cleanup here unless the backend supports cancellation.
-      if (error.name === 'AbortError') {
-        // Log or handle abortion if needed
-      } else {
-        console.error('Prompt API Polyfill Error:', error);
-      }
-      throw error;
-    }
-  }
-
-  promptStreaming(input, options = {}) {
-    this.#validateContext();
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (this.#window.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    if (
-      typeof input === 'object' &&
-      input !== null &&
-      !Array.isArray(input) &&
-      Object.keys(input).length === 0
-    ) {
-      return new ReadableStream({
-        start(controller) {
-          // This is done to pass a WPT test and work around a safety feature in
-          // Gemma that refuses to follow instructions to respond with
-          // "[object Object]". We skip the model and return the expected response
-          // directly.
-          controller.enqueue('[object Object]');
-          controller.close();
-        },
-      });
-    }
-
-    const _this = this; // Capture 'this' to access private fields in callback
-
-    const signal = options.signal;
-
-    return new ReadableStream({
-      async start(controller) {
-        let aborted = false;
-        const onAbort = () => {
-          aborted = true;
-          try {
-            const error =
-              signal?.reason ||
-              new (_this.#window.DOMException || globalThis.DOMException)(
-                'Aborted',
-                'AbortError'
-              );
-            controller.error(error);
-          } catch {
-            // Ignore
-          }
-        };
-
-        if (signal?.aborted) {
-          onAbort();
-          return;
-        }
-
-        if (signal) {
-          signal.addEventListener('abort', onAbort);
-        }
-
-        try {
-          if (options.responseConstraint) {
-            LanguageModel.#validateResponseConstraint(
-              options.responseConstraint,
-              _this.#window
-            );
-            const schema = convertJsonSchemaToVertexSchema(
-              options.responseConstraint
-            );
-            _this.#sessionParams.generationConfig.responseMimeType =
-              'application/json';
-            _this.#sessionParams.generationConfig.responseSchema = schema;
-            _this.#model = _this.#backend.createSession(
-              _this.#options,
-              _this.#sessionParams
-            );
-          }
-
-          const workaroundPrefix = _this.#getWorkaroundPrefix(input);
-          const parts = await _this.#processInput(input);
-          if (_this.#destroyed) {
-            throw new (_this.#window.DOMException || globalThis.DOMException)(
-              'Session is destroyed',
-              'InvalidStateError'
-            );
-          }
-          const userContent = { role: 'user', parts: parts };
-
-          const detection = _this.#isVolkswagenDetection(parts);
-          if (detection === 'QuotaExceededError') {
-            const ErrorClass =
-              (_this.#window && _this.#window.QuotaExceededError) ||
-              (_this.#window && _this.#window.DOMException) ||
-              globalThis.QuotaExceededError ||
-              globalThis.DOMException;
-            const error = new ErrorClass(
-              'The prompt is too large, it exceeds the quota.',
-              'QuotaExceededError'
-            );
-            // Attach properties expected by WPT tests
-            Object.defineProperty(error, 'code', {
-              value: 22,
-              configurable: true,
-            });
-            const kLargeCount = 10000000;
-            error.requested = kLargeCount;
-            error.quota = _this.inputQuota;
-            throw error;
-          } else if (detection === 'quotaoverflow') {
-            _this.dispatchEvent(new Event('quotaoverflow'));
-            controller.enqueue('Mock response for quota overflow test.');
-            controller.close();
-            return;
-          }
-
-          const fullHistoryWithNewPrompt = [..._this.#history, userContent];
-          if (_this.#sessionParams.systemInstruction) {
-            fullHistoryWithNewPrompt.unshift({
-              role: 'system',
-              parts: [{ text: _this.#sessionParams.systemInstruction }],
-            });
-          }
-
-          const totalTokens = await _this.#backend.countTokens(
-            fullHistoryWithNewPrompt
-          );
-
-          if (totalTokens > _this.inputQuota) {
-            const ErrorClass =
-              (_this.#window && _this.#window.QuotaExceededError) ||
-              (_this.#window && _this.#window.DOMException) ||
-              globalThis.QuotaExceededError ||
-              globalThis.DOMException;
-            const error = new ErrorClass(
-              `The prompt is too large (${totalTokens} tokens), it exceeds the quota of ${_this.inputQuota} tokens.`,
-              'QuotaExceededError'
-            );
-            // Attach properties expected by WPT tests
-            Object.defineProperty(error, 'code', {
-              value: 22,
-              configurable: true,
-            });
-            error.requested = totalTokens;
-            error.quota = _this.inputQuota;
-            throw error;
-          }
-
-          if (totalTokens > _this.inputQuota) {
-            _this.dispatchEvent(new Event('quotaoverflow'));
-          }
-
-          const requestContents = [..._this.#history, userContent];
-
-          let stream;
-          try {
-            stream =
-              await _this.#backend.generateContentStream(requestContents);
-          } catch (error) {
-            _this.#handleBackendError(error, parts);
-            throw error;
-          }
-
-          let fullResponseText = '';
-          let prefixStripped = false;
-          let buffer = '';
-
-          for await (const chunk of stream) {
-            if (aborted) {
-              // Try to cancel if supported
-              if (typeof stream.return === 'function') {
-                await stream.return();
-              }
-              return;
-            }
-
-            let chunkText = chunk.text();
-            if (workaroundPrefix && !prefixStripped) {
-              buffer += chunkText;
-              const match = buffer.match(/^\s*{\s*"Rating"\s*:\s*/);
-              if (match) {
-                // Workaround for WPT: `prefix` is not supported and this modification
-                // of the response is done just to pass a test.
-                chunkText = buffer.slice(match[0].length);
-                prefixStripped = true;
-                buffer = ''; // Exit buffering
-              } else if (buffer.length > 50) {
-                // We've buffered enough and didn't find the prefix, probably not there.
-                chunkText = buffer;
-                prefixStripped = true;
-                buffer = '';
-              } else {
-                // Still waiting for more chunks to decide.
-                continue;
-              }
-            }
-            fullResponseText += chunkText;
-
-            if (chunk.usageMetadata?.totalTokenCount) {
-              _this.#inputUsage = chunk.usageMetadata.totalTokenCount;
-            }
-
-            controller.enqueue(chunkText);
-          }
-
-          if (!aborted) {
-            _this.#history.push(userContent);
-            _this.#history.push({
-              role: 'model',
-              parts: [{ text: fullResponseText }],
-            });
-
-            controller.close();
-          }
-        } catch (error) {
-          if (!aborted) {
-            controller.error(error);
-          }
-        } finally {
-          if (signal) {
-            signal.removeEventListener('abort', onAbort);
-          }
-        }
-      },
-    });
-  }
-
-  async append(input, options = {}) {
-    this.#validateContext();
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    if (options.signal?.aborted) {
-      throw (
-        options.signal.reason ||
-        new (this.#window.DOMException || globalThis.DOMException)(
-          'Aborted',
-          'AbortError'
-        )
-      );
-    }
-
-    const parts = await this.#processInput(input);
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-    const content = { role: 'user', parts: parts };
-
-    this.#history.push(content);
-
-    try {
-      const fullHistory = [...this.#history];
-      if (this.#sessionParams.systemInstruction) {
-        fullHistory.unshift({
-          role: 'system',
-          parts: [{ text: this.#sessionParams.systemInstruction }],
-        });
-      }
-      const totalTokens = await this.#backend.countTokens(fullHistory);
-      this.#inputUsage = totalTokens || 0;
-    } catch {
-      // Do nothing.
-    }
-
-    if (this.#inputUsage > this.inputQuota) {
-      this.dispatchEvent(new Event('quotaoverflow'));
-    }
-  }
-
-  async measureInputUsage(input) {
-    this.#validateContext();
-    if (this.#destroyed) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'Session is destroyed',
-        'InvalidStateError'
-      );
-    }
-
-    try {
-      const parts = await this.#processInput(input);
-      if (this.#destroyed) {
-        throw new (this.#window.DOMException || globalThis.DOMException)(
-          'Session is destroyed',
-          'InvalidStateError'
-        );
-      }
-
-      const detection = this.#isVolkswagenDetection(parts);
-      if (detection === 'QuotaExceededError') {
-        return 10000000; // Match the kLargeCount in prompt()
-      } else if (detection === 'quotaoverflow') {
-        return 500000; // Mock large but under quota token count
-      }
-
-      const totalTokens = await this.#backend.countTokens([
-        { role: 'user', parts },
-      ]);
-      return totalTokens || 0;
-    } catch (e) {
-      console.warn(
-        'The underlying API call failed, quota usage (0) is not reported accurately.'
-      );
-      return 0;
-    }
-  }
-
-  // Volkswagen mode detection to avoid cloud costs for WPT tests.
-  #isVolkswagenDetection(parts) {
-    return LanguageModel.#isVolkswagenDetectionStatic(parts);
-  }
-
-  static #isVolkswagenDetectionStatic(parts) {
-    if (parts.length !== 1 || !parts[0].text) {
-      return null;
-    }
-    const text = parts[0].text;
-    const kTestPrompt = 'Please write a sentence in English.';
-    if (typeof text !== 'string' || !text.startsWith(kTestPrompt)) {
-      return null;
-    }
-
-    // Detect the exact condition from the WPT test.
-    // Case 1: Overall usage exceeds quota (fires quotaoverflow event).
-    // Case 2: Prompt itself exceeds quota (throws QuotaExceededError).
-    if (text.length > 10000000) {
-      // Large enough to exceed quota if used in .repeat(inputQuota)
-      return 'QuotaExceededError';
-    }
-    if (text.length > 50000) {
-      // >50k chars (Test 1)
-      return 'quotaoverflow';
-    }
-    return null;
-  }
-
-  static #validateResponseConstraint(constraint, win) {
-    if (!constraint) {
-      return;
-    }
-    try {
-      JSON.stringify(constraint);
-    } catch (e) {
-      throw new (win.DOMException || globalThis.DOMException)(
-        'Response json schema is invalid - it should be an object that can be stringified into a JSON string.',
-        'NotSupportedError'
-      );
-    }
-  }
-
-  #getWorkaroundPrefix(input) {
-    if (Array.isArray(input)) {
-      for (const msg of input) {
-        if (
-          msg.prefix &&
-          (msg.role === 'assistant' || msg.role === 'model') &&
-          typeof msg.content === 'string' &&
-          msg.content.includes('"Rating":')
-        ) {
-          return msg.content;
-        }
-      }
-    }
-    return null;
-  }
-
-  // Private Helper to process diverse input types
-  async #processInput(input) {
-    const allowedInputs = this.#options.expectedInputs
-      ? ['text', ...this.#options.expectedInputs.map((i) => i.type)]
-      : ['text'];
-
-    if (typeof input === 'string') {
-      if (!allowedInputs.includes('text')) {
-        throw new (this.#window.DOMException || globalThis.DOMException)(
-          'The content type "text" is not in the expectedInputs.',
-          'NotSupportedError'
-        );
-      }
-      return [{ text: input === '' ? ' ' : input }];
-    }
-
-    if (Array.isArray(input)) {
-      if (input.length === 0) {
-        return [{ text: ' ' }];
-      }
-      if (input.length > 0 && input[0].role) {
-        let combinedParts = [];
-        for (const msg of input) {
-          const isAssistant = msg.role === 'assistant' || msg.role === 'model';
-          if (typeof msg.content === 'string') {
-            if (!allowedInputs.includes('text')) {
-              throw new (this.#window.DOMException || globalThis.DOMException)(
-                'The content type "text" is not in the expectedInputs.',
-                'NotSupportedError'
-              );
-            }
-            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) {
-              const type = c.type || 'text';
-              if (!allowedInputs.includes(type)) {
-                throw new (
-                  this.#window.DOMException || globalThis.DOMException
-                )(
-                  `The content type "${type}" is not in the expectedInputs.`,
-                  'NotSupportedError'
-                );
-              }
-              if (type === 'text') {
-                if (typeof c.value !== 'string') {
-                  throw new (
-                    this.#window.DOMException || globalThis.DOMException
-                  )(
-                    'The content type "text" must have a string value.',
-                    'SyntaxError'
-                  );
-                }
-                combinedParts.push({ text: c.value });
-              } else {
-                if (isAssistant) {
-                  throw new (
-                    this.#window.DOMException || globalThis.DOMException
-                  )(
-                    'Assistant messages only support text content.',
-                    'NotSupportedError'
-                  );
-                }
-                const part = await MultimodalConverter.convert(c.type, c.value);
-                combinedParts.push(part);
-              }
-            }
-          }
-        }
-        return combinedParts;
-      }
-      return input.map((s) => {
-        if (!allowedInputs.includes('text')) {
-          throw new (this.#window.DOMException || globalThis.DOMException)(
-            'The content type "text" is not in the expectedInputs.',
-            'NotSupportedError'
-          );
-        }
-        return { text: String(s) };
-      });
-    }
-
-    if (!allowedInputs.includes('text')) {
-      throw new (this.#window.DOMException || globalThis.DOMException)(
-        'The content type "text" is not in the expectedInputs.',
-        'NotSupportedError'
-      );
-    }
-    const text = JSON.stringify(input);
-    return [{ text }];
-  }
-
-  // Map backend errors to WPT expectations
-  #handleBackendError(error, parts) {
-    const msg = String(error.message || error);
-    if (
-      msg.includes('400') ||
-      msg.toLowerCase().includes('unable to process') ||
-      msg.toLowerCase().includes('invalid')
-    ) {
-      const hasAudio = parts.some((p) =>
-        p.inlineData?.mimeType.startsWith('audio/')
-      );
-      const hasImage = parts.some((p) =>
-        p.inlineData?.mimeType.startsWith('image/')
-      );
-
-      const DOMExceptionClass =
-        this.#window.DOMException || globalThis.DOMException;
-      if (hasAudio) {
-        throw new DOMExceptionClass('Invalid audio data', 'DataError');
-      }
-      if (hasImage) {
-        throw new DOMExceptionClass('Invalid image data', 'InvalidStateError');
-      }
-    }
-  }
-}
-
-// --- Injection and Globals ---
-
-// Some WPT tests expect QuotaExceededError to be a global for constructor comparison.
-if (globalThis.DOMException) {
-  globalThis.QuotaExceededError = globalThis.DOMException;
-}
-
-// Subclassing per window to handle detached iframes
-const inject = (win) => {
-  try {
-    if (!win || win.LanguageModel?.__isPolyfill) {
-      return;
-    }
-
-    const LocalLanguageModel = class extends LanguageModel {};
-    LocalLanguageModel.__window = win;
-    LocalLanguageModel.__isPolyfill = true;
-    win.LanguageModel = LocalLanguageModel;
-
-    // Ensure QuotaExceededError is also available in the iframe for WPT tests
-    if (win.DOMException) {
-      win.QuotaExceededError = win.DOMException;
-    }
-  } catch (e) {
-    // Ignore cross-origin errors
-  }
-};
-
-// Injection logic
-if (typeof HTMLIFrameElement !== 'undefined') {
-  try {
-    const descriptor = Object.getOwnPropertyDescriptor(
-      HTMLIFrameElement.prototype,
-      'contentWindow'
-    );
-    if (descriptor && descriptor.get) {
-      Object.defineProperty(HTMLIFrameElement.prototype, 'contentWindow', {
-        get() {
-          const win = descriptor.get.call(this);
-          if (win) {
-            inject(win);
-          }
-          return win;
-        },
-        configurable: true,
-      });
-    }
-  } catch (e) {
-    // Ignore
-  }
-}
-
-const observer = new MutationObserver((mutations) => {
-  for (const mutation of mutations) {
-    for (const node of mutation.addedNodes) {
-      if (node.tagName === 'IFRAME') {
-        inject(node.contentWindow);
-        node.addEventListener('load', () => inject(node.contentWindow), {
-          once: false,
-        });
-      }
-    }
-  }
-});
-
-if (globalThis.document?.documentElement) {
-  observer.observe(globalThis.document.documentElement, {
-    childList: true,
-    subtree: true,
-  });
-  globalThis.document.querySelectorAll('iframe').forEach((iframe) => {
-    inject(iframe.contentWindow);
-  });
-}
-
-// Main attachment
-if (
-  !('LanguageModel' in globalThis) ||
-  globalThis.__FORCE_PROMPT_API_POLYFILL__
-) {
-  globalThis.LanguageModel = LanguageModel;
-  LanguageModel.__isPolyfill = true;
-  console.log(
-    'Polyfill: window.LanguageModel is now backed by the Prompt API polyfill.'
-  );
-}