prompt-api-polyfill 1.0.0 → 1.1.0

package/dist/backends/gemini.js

@@ -0,0 +1,55 @@
+import { GoogleGenAI as s } from "@google/genai";
+import { P as a, D as i } from "../chunks/defaults-CNQngzSd.js";
+class u extends a {
+  #n;
+  #e;
+  #t;
+  constructor(t) {
+    super(t.modelName || i.gemini.modelName), this.#n = new s({ apiKey: t.apiKey });
+  }
+  createSession(t, e) {
+    return this.#t = e, this.#e = t.modelName || this.modelName, { model: this.#e, params: e };
+  }
+  async generateContent(t) {
+    const e = {
+      systemInstruction: this.#t.systemInstruction,
+      temperature: this.#t.generationConfig?.temperature,
+      topK: this.#t.generationConfig?.topK
+    }, n = await this.#n.models.generateContent({
+      model: this.#e,
+      contents: t,
+      config: e
+    }), o = n.usageMetadata?.promptTokenCount || 0;
+    return { text: n.text, usage: o };
+  }
+  async generateContentStream(t) {
+    const e = {
+      systemInstruction: this.#t.systemInstruction,
+      temperature: this.#t.generationConfig?.temperature,
+      topK: this.#t.generationConfig?.topK
+    }, n = await this.#n.models.generateContentStream({
+      model: this.#e,
+      contents: t,
+      config: e
+    });
+    return (async function* () {
+      for await (const o of n)
+        yield {
+          text: () => o.text,
+          usageMetadata: {
+            totalTokenCount: o.usageMetadata?.totalTokenCount || 0
+          }
+        };
+    })();
+  }
+  async countTokens(t) {
+    const { totalTokens: e } = await this.#n.models.countTokens({
+      model: this.#e,
+      contents: t
+    });
+    return e;
+  }
+}
+export {
+  u as default
+};

package/dist/backends/openai.js

@@ -0,0 +1,199 @@
+import u from "openai";
+import { P as m, D as l } from "../chunks/defaults-CNQngzSd.js";
+class y extends m {
+  #e;
+  constructor(t) {
+    super(t.modelName || l.openai.modelName), this.config = t, this.openai = new u({
+      apiKey: t.apiKey,
+      dangerouslyAllowBrowser: !0
+      // Required for client-side usage
+    });
+  }
+  static availability(t = {}) {
+    if (t.expectedInputs) {
+      const s = t.expectedInputs.some(
+        (e) => e.type === "audio"
+      ), r = t.expectedInputs.some(
+        (e) => e.type === "image"
+      );
+      if (s && r)
+        return "unavailable";
+    }
+    return "available";
+  }
+  createSession(t, s) {
+    this.#e = {
+      model: t.modelName || this.modelName,
+      temperature: s.generationConfig?.temperature,
+      top_p: 1,
+      // Default to 1.0 as topK is not directly supported the same way
+      systemInstruction: s.systemInstruction
+    };
+    const r = s.generationConfig || {};
+    if (r.responseSchema) {
+      const { schema: e, wrapped: o } = this.#o(
+        r.responseSchema
+      );
+      this.#e.response_format = {
+        type: "json_schema",
+        json_schema: {
+          name: "response",
+          strict: !0,
+          schema: e
+        }
+      }, this.#e.response_wrapped = o;
+    } else r.responseMimeType === "application/json" && (this.#e.response_format = { type: "json_object" });
+    return this.#e;
+  }
+  /**
+   * OpenAI Structured Outputs require:
+   * 1. All fields in objects to be marked as 'required'.
+   * 2. Objects to have 'additionalProperties: false'.
+   * 3. The root must be an 'object'.
+   */
+  #o(t) {
+    if (typeof t != "object" || t === null)
+      return { schema: t, wrapped: !1 };
+    const s = (e) => {
+      if (e.type === "object")
+        if (e.properties) {
+          e.additionalProperties = !1, e.required = Object.keys(e.properties);
+          for (const o in e.properties)
+            s(e.properties[o]);
+        } else
+          e.additionalProperties = !1, e.required = [];
+      else e.type === "array" && e.items && s(e.items);
+      return e;
+    }, r = JSON.parse(JSON.stringify(t));
+    return r.type !== "object" ? {
+      wrapped: !0,
+      schema: {
+        type: "object",
+        properties: { value: r },
+        required: ["value"],
+        additionalProperties: !1
+      }
+    } : {
+      wrapped: !1,
+      schema: s(r)
+    };
+  }
+  #t(t) {
+    let s = !1, r = !1;
+    for (const e of t)
+      if (Array.isArray(e.content))
+        for (const o of e.content)
+          o.type === "image_url" && (s = !0), o.type === "input_audio" && (r = !0);
+    if (s && r)
+      throw new Error(
+        "OpenAI backend does not support mixing images and audio in the same session. Please start a new session."
+      );
+    return { hasImage: s, hasAudio: r };
+  }
+  #s(t) {
+    return this.#e.model !== this.modelName ? this.#e.model : t ? `${this.modelName}-audio-preview` : this.modelName;
+  }
+  async generateContent(t) {
+    const { messages: s } = this.#r(
+      t,
+      this.#e.systemInstruction
+    ), { hasAudio: r } = this.#t(s), e = this.#s(r);
+    if (e === `${this.modelName}-audio-preview` && this.#e.response_format)
+      throw new DOMException(
+        `OpenAI audio model ('${e}') does not support structured outputs (responseConstraint).`,
+        "NotSupportedError"
+      );
+    const o = {
+      model: e,
+      messages: s
+    };
+    this.#e.temperature > 0 && (o.temperature = this.#e.temperature), this.#e.response_format && (o.response_format = this.#e.response_format);
+    try {
+      const a = await this.openai.chat.completions.create(o);
+      let i = a.choices[0].message.content;
+      if (this.#e.response_wrapped && i)
+        try {
+          const c = JSON.parse(i);
+          c && typeof c == "object" && "value" in c && (i = JSON.stringify(c.value));
+        } catch {
+        }
+      const n = a.usage?.prompt_tokens || 0;
+      return { text: i, usage: n };
+    } catch (a) {
+      throw console.error("OpenAI Generate Content Error:", a), a;
+    }
+  }
+  async generateContentStream(t) {
+    const { messages: s } = this.#r(
+      t,
+      this.#e.systemInstruction
+    ), { hasAudio: r } = this.#t(s), e = this.#s(r);
+    if (e === `${this.modelName}-audio-preview` && this.#e.response_format)
+      throw new DOMException(
+        `OpenAI audio model ('${e}') does not support structured outputs (responseConstraint).`,
+        "NotSupportedError"
+      );
+    const o = {
+      model: e,
+      messages: s,
+      stream: !0
+    };
+    this.#e.temperature > 0 && (o.temperature = this.#e.temperature), this.#e.response_format && (o.response_format = this.#e.response_format);
+    try {
+      const a = await this.openai.chat.completions.create(o);
+      return (async function* () {
+        let p = !0;
+        for await (const i of a) {
+          let n = i.choices[0]?.delta?.content;
+          n && (yield {
+            text: () => n,
+            usageMetadata: { totalTokenCount: 0 }
+          });
+        }
+      })();
+    } catch (a) {
+      throw console.error("OpenAI Generate Content Stream Error:", a), a;
+    }
+  }
+  async countTokens(t) {
+    let s = "";
+    if (Array.isArray(t)) {
+      for (const r of t)
+        if (r.parts)
+          for (const e of r.parts)
+            e.text ? s += e.text : e.inlineData && (s += " ".repeat(1e3));
+    }
+    return Math.ceil(s.length / 4);
+  }
+  #r(t, s) {
+    const r = [];
+    s && r.push({
+      role: "system",
+      content: s
+    });
+    for (const e of t) {
+      const o = e.role === "model" ? "assistant" : "user", a = [];
+      for (const p of e.parts)
+        if (p.text)
+          a.push({ type: "text", text: p.text });
+        else if (p.inlineData) {
+          const { data: i, mimeType: n } = p.inlineData;
+          n.startsWith("image/") ? a.push({
+            type: "image_url",
+            image_url: { url: `data:${n};base64,${i}` }
+          }) : n.startsWith("audio/") && a.push({
+            type: "input_audio",
+            input_audio: {
+              data: i,
+              format: n.split("/")[1] === "mpeg" ? "mp3" : "wav"
+            }
+          });
+        }
+      r.push({ role: o, content: a });
+    }
+    return { messages: r };
+  }
+}
+export {
+  y as default
+};

package/dist/backends/transformers.js

@@ -0,0 +1,254 @@
+import { pipeline as z, TextStreamer as C } from "@huggingface/transformers";
+import { P as j, D as y } from "../chunks/defaults-CNQngzSd.js";
+class D extends j {
+  #e;
+  #t;
+  #a;
+  #n;
+  #o;
+  constructor(n = {}) {
+    super(n.modelName || y.transformers.modelName), this.#a = n.device || y.transformers.device, this.#n = n.dtype || y.transformers.dtype;
+  }
+  /**
+   * Loaded models can be large, so we initialize them lazily.
+   * @param {EventTarget} [monitorTarget] - The event target to dispatch download progress events to.
+   * @returns {Promise<Object>} The generator.
+   */
+  async #s(n) {
+    if (!this.#e) {
+      const t = /* @__PURE__ */ new Map(), a = await $(this.modelName, {
+        dtype: this.#n
+      });
+      for (const { path: e, size: o } of a)
+        t.set(e, { loaded: 0, total: o });
+      const i = (e) => {
+        if (!n)
+          return;
+        const o = 1 / 65536, c = Math.floor(e / o) * o;
+        c <= n.__lastProgressLoaded || (n.dispatchEvent(
+          new ProgressEvent("downloadprogress", {
+            loaded: c,
+            total: 1,
+            lengthComputable: !0
+          })
+        ), n.__lastProgressLoaded = c);
+      }, l = (e) => {
+        if (e.status === "initiate")
+          if (t.has(e.file)) {
+            const o = t.get(e.file);
+            e.total && (o.total = e.total);
+          } else
+            t.set(e.file, { loaded: 0, total: e.total || 0 });
+        else if (e.status === "progress")
+          t.has(e.file) && (t.get(e.file).loaded = e.loaded);
+        else if (e.status === "done") {
+          if (t.has(e.file)) {
+            const o = t.get(e.file);
+            o.loaded = o.total;
+          }
+        } else if (e.status === "ready") {
+          i(1);
+          return;
+        }
+        if (e.status === "progress" || e.status === "done") {
+          let o = 0, c = 0;
+          for (const { loaded: f, total: d } of t.values())
+            o += f, c += d;
+          if (c > 0) {
+            const f = o / c;
+            i(Math.min(f, 0.9999));
+          }
+        }
+      };
+      i(0), this.#e = await z("text-generation", this.modelName, {
+        device: this.#a,
+        dtype: this.#n,
+        progress_callback: l
+      }), this.#t = this.#e.tokenizer;
+    }
+    return this.#e;
+  }
+  /**
+   * Checks if the backend is available given the options.
+   * @param {Object} options - LanguageModel options.
+   * @returns {string} 'available' or 'unavailable'.
+   */
+  static availability(n) {
+    if (n?.expectedInputs && Array.isArray(n.expectedInputs)) {
+      for (const t of n.expectedInputs)
+        if (t.type === "audio" || t.type === "image")
+          return "unavailable";
+    }
+    return "available";
+  }
+  /**
+   * Creates a new session.
+   * @param {Object} options - LanguageModel options.
+   * @param {Object} sessionParams - Session parameters.
+   * @param {EventTarget} [monitorTarget] - The event target to dispatch download progress events to.
+   * @returns {Promise<Object>} The generator.
+   */
+  async createSession(n, t, a) {
+    return n.responseConstraint && console.warn(
+      "The `responseConstraint` flag isn't supported by the Transformers.js backend and was ignored."
+    ), await this.#s(a), this.generationConfig = {
+      max_new_tokens: 512,
+      // Default limit
+      temperature: t.generationConfig?.temperature ?? 1,
+      top_p: 1,
+      do_sample: t.generationConfig?.temperature !== 0,
+      return_full_text: !1
+    }, this.#o = t.systemInstruction, this.#e;
+  }
+  async generateContent(n) {
+    const t = await this.#s(), a = this.#r(n), i = this.#t.apply_chat_template(a, {
+      tokenize: !1,
+      add_generation_prompt: !0
+    }), e = (await t(i, {
+      ...this.generationConfig,
+      add_special_tokens: !1
+    }))[0].generated_text, o = await this.countTokens(n);
+    return { text: e, usage: o };
+  }
+  async generateContentStream(n) {
+    const t = await this.#s(), a = this.#r(n), i = this.#t.apply_chat_template(a, {
+      tokenize: !1,
+      add_generation_prompt: !0
+    }), l = [];
+    let e, o = new Promise((r) => e = r), c = !1;
+    const f = (r) => {
+      l.push(r), e && (e(), e = null);
+    }, d = new C(this.#t, {
+      skip_prompt: !0,
+      skip_special_tokens: !0,
+      callback_function: f
+    });
+    return t(i, {
+      ...this.generationConfig,
+      add_special_tokens: !1,
+      streamer: d
+    }).then(() => {
+      c = !0, e && (e(), e = null);
+    }).catch((r) => {
+      console.error("[Transformers.js] Generation error:", r), c = !0, e && (e(), e = null);
+    }), (async function* () {
+      for (; ; ) {
+        for (l.length === 0 && !c && (e || (o = new Promise((r) => e = r)), await o); l.length > 0; ) {
+          const r = l.shift();
+          yield {
+            text: () => r,
+            usageMetadata: { totalTokenCount: 0 }
+          };
+        }
+        if (c)
+          break;
+      }
+    })();
+  }
+  async countTokens(n) {
+    await this.#s();
+    const t = this.#r(n);
+    return this.#t.apply_chat_template(t, {
+      tokenize: !0,
+      add_generation_prompt: !1,
+      return_tensor: !1
+    }).length;
+  }
+  #r(n) {
+    const t = n.map((a) => {
+      let i = a.role === "model" ? "assistant" : a.role === "system" ? "system" : "user";
+      const l = a.parts.map((e) => e.text).join("");
+      return { role: i, content: l };
+    });
+    if (this.#o && !t.some((a) => a.role === "system") && t.unshift({ role: "system", content: this.#o }), this.modelName.toLowerCase().includes("gemma")) {
+      const a = t.findIndex((i) => i.role === "system");
+      if (a !== -1) {
+        const i = t[a], l = t.findIndex(
+          (e, o) => e.role === "user" && o > a
+        );
+        l !== -1 ? (t[l].content = i.content + `
+
+` + t[l].content, t.splice(a, 1)) : (i.content += `
+
+`, i.role = "user");
+      }
+    }
+    return t;
+  }
+}
+async function $(g, n = {}) {
+  const { dtype: t = "q8", branch: a = "main" } = n;
+  let i = null;
+  const l = `transformers_model_files_${g}_${t}_${a}`;
+  try {
+    const s = localStorage.getItem(l);
+    if (s) {
+      i = JSON.parse(s);
+      const { timestamp: p, files: u } = i, v = 1440 * 60 * 1e3;
+      if (Date.now() - p < v)
+        return u;
+    }
+  } catch (s) {
+    console.warn("Failed to read from localStorage cache:", s);
+  }
+  const e = `https://huggingface.co/api/models/${g}/tree/${a}?recursive=true`;
+  let o;
+  try {
+    if (o = await fetch(e), !o.ok)
+      throw new Error(`Manifest fetch failed: ${o.status}`);
+  } catch (s) {
+    if (i)
+      return console.warn(
+        "Failed to fetch manifest from network, falling back to cached data (expired):",
+        s
+      ), i.files;
+    throw s;
+  }
+  const c = await o.json(), f = new Map(c.map((s) => [s.path, s.size])), d = [], h = (s) => f.has(s), r = (s) => h(s) ? (d.push({ path: s, size: f.get(s) }), !0) : !1;
+  r("config.json"), r("generation_config.json"), r("preprocessor_config.json"), h("tokenizer.json") ? (r("tokenizer.json"), r("tokenizer_config.json")) : (r("tokenizer_config.json"), r("special_tokens_map.json"), r("vocab.json"), r("merges.txt"), r("vocab.txt"));
+  const w = "onnx";
+  let m = [];
+  t === "fp32" ? m = [""] : t === "quantized" ? m = ["_quantized"] : (m = [`_${t}`], t === "q8" && m.push(""));
+  let k = [
+    "model",
+    "encoder_model",
+    "decoder_model",
+    "decoder_model_merged"
+  ];
+  const _ = [];
+  for (const s of k)
+    for (const p of m) {
+      const u = `${w}/${s}${p}.onnx`;
+      if (h(u)) {
+        _.push(u);
+        break;
+      }
+    }
+  const x = _.some(
+    (s) => s.includes("decoder_model_merged")
+  ), b = _.filter((s) => !(x && s.includes("decoder_model") && !s.includes("merged")));
+  for (const s of b) {
+    r(s);
+    const p = `${s}_data`;
+    if (r(p)) {
+      let u = 1;
+      for (; r(`${p}_${u}`); )
+        u++;
+    }
+  }
+  try {
+    localStorage.setItem(
+      l,
+      JSON.stringify({
+        timestamp: Date.now(),
+        files: d
+      })
+    );
+  } catch (s) {
+    console.warn("Failed to write to localStorage cache:", s);
+  }
+  return d;
+}
+export {
+  D as default
+};

package/{backends/base.js → dist/chunks/defaults-CNQngzSd.js}

@@ -1,60 +1,65 @@
-/**
- * Abstract class representing a backend for the LanguageModel polyfill.
- */
-export default class PolyfillBackend {
-  #model;
-
+class r {
+  #e;
   /**
    * @param {string} modelName - The name of the model.
    */
-  constructor(modelName) {
-    this.modelName = modelName;
+  constructor(e) {
+    this.modelName = e;
   }
-
   /**
    * Checks if the backend is available given the options.
    * @param {Object} options - LanguageModel options.
    * @returns {string} 'available', 'unavailable', 'downloadable', or 'downloading'.
    */
-  static availability(options) {
-    return 'available';
+  static availability(e) {
+    return "available";
   }
-
   /**
    * Creates a model session and stores it.
    * @param {Object} options - LanguageModel options.
    * @param {Object} sessionParams - Parameters for the cloud or local model.
-   * @param {Object} monitorTarget - Object to report download progress to.
+   * @param {EventTarget} [monitorTarget] - The event target to dispatch download progress events to.
    * @returns {any} The created session object.
    */
-  createSession(options, sessionParams, monitorTarget) {
-    throw new Error('Not implemented');
+  createSession(e, o, n) {
+    throw new Error("Not implemented");
   }
-
   /**
    * Generates content (non-streaming).
    * @param {Array} content - The history + new message content.
    * @returns {Promise<{text: string, usage: number}>}
    */
-  async generateContent(content) {
-    throw new Error('Not implemented');
+  async generateContent(e) {
+    throw new Error("Not implemented");
   }
-
   /**
    * Generates content stream.
    * @param {Array} content - The history + new content.
    * @returns {Promise<AsyncIterable>} Stream of chunks.
    */
-  async generateContentStream(content) {
-    throw new Error('Not implemented');
+  async generateContentStream(e) {
+    throw new Error("Not implemented");
   }
-
   /**
    * Counts tokens.
    * @param {Array} content - The content to count.
    * @returns {Promise<number>} Total tokens.
    */
-  async countTokens(content) {
-    throw new Error('Not implemented');
+  async countTokens(e) {
+    throw new Error("Not implemented");
   }
 }
+const a = {
+  firebase: { modelName: "gemini-2.5-flash-lite" },
+  gemini: { modelName: "gemini-2.0-flash-lite-preview-02-05" },
+  openai: { modelName: "gpt-4o" },
+  transformers: {
+    modelName: "onnx-community/gemma-3-1b-it-ONNX-GQA",
+    device: "webgpu",
+    dtype: "q4f16"
+  }
+};
+export {
+  a as D,
+  r as P
+};