@leuria/prompt-api 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,33 @@
+# @leuria/prompt-api
+
+The [Prompt API](https://github.com/webmachinelearning/prompt-api) (`LanguageModel`) where the browser can't run it, served by the visitor's own AI through [Leuria](https://leuria.eu). Write your feature for the web standard once: where the browser has a built-in model that runs, it answers; elsewhere, the visitor's AI does (ChatGPT, Claude, Mistral or a local model), in any browser.
+
+```ts
+import { installPromptAPI } from "@leuria/prompt-api"
+
+await installPromptAPI({ app: "My notes" })
+
+if ((await LanguageModel.availability()) !== "unavailable") {
+  // From a click the first time: the visitor approves your site in Leuria.
+  const session = await LanguageModel.create({ initialPrompts: [{ role: "system", content: "You are concise." }] })
+  console.log(await session.prompt("Summarize this note: …"))
+}
+```
+
+`installPromptAPI` keeps the browser's own `LanguageModel` wherever it can run (`when: "unavailable"`, the default). Use `when: "missing"` to step in only where the browser has none, or `createLanguageModel()` to get the class without touching the global.
+
+## How the API maps onto Leuria
+
+| Prompt API | With Leuria |
+| --- | --- |
+| `availability()` | `"available"` once the site is connected, `"downloadable"` before (connecting is the "download"), `"unavailable"` without Leuria |
+| `create()` | From a click the first time: Leuria asks the visitor to approve the site. `downloadprogress` reports 0, then 1 |
+| `prompt()`, `promptStreaming()` | One session of the visitor's AI per `LanguageModel`; each prompt sends only what's new |
+| `tools` | Run in your page, called by the visitor's AI |
+| `responseConstraint` | JSON Schema or RegExp, given to the AI and checked; a mismatch goes back to the AI to fix |
+| `append()`, `clone()`, `destroy()`, `signal` | Supported |
+| Images | Supported when the visitor's AI takes them. Audio is not supported |
+| `contextUsage`, `measureContextUsage()` | Estimates (about 4 characters per token) |
+| `topK`, `temperature`, `samplingMode` | Accepted and ignored: the visitor's AI sets its own |
+
+Docs: [leuria.dev](https://leuria.dev). Apache-2.0.

package/dist/index.d.ts

@@ -0,0 +1,231 @@
+import { BridgeProviderOptions, Provider, Message, ProviderSession } from '@leuria/client';
+
+/**
+ * `responseConstraint`: a JSON Schema or a RegExp. The visitor's AI gets
+ * it as an instruction, and the answer is checked here; a mismatch is
+ * sent back to the AI to fix, a few times at most.
+ */
+type ResponseConstraint = Record<string, unknown> | RegExp;
+
+/**
+ * Prompt API input (`LanguageModelPrompt`, `initialPrompts`) to Leuria
+ * messages. The spec's rules on roles and `prefix` are enforced here, with
+ * the exceptions Chrome throws.
+ */
+
+type LanguageModelMessageRole = "system" | "user" | "assistant";
+type LanguageModelMessageType = "text" | "image" | "audio" | "tool-call" | "tool-response";
+interface LanguageModelMessageContent {
+    type: LanguageModelMessageType;
+    value: unknown;
+}
+interface LanguageModelMessage {
+    role: LanguageModelMessageRole;
+    content: string | LanguageModelMessageContent[];
+    prefix?: boolean;
+}
+type LanguageModelPrompt = string | LanguageModelMessage[];
+
+/**
+ * `LanguageModel`, the Prompt API's interface, over a Leuria provider: by
+ * default the visitor's own AI through the Leuria app.
+ *
+ * How the spec maps onto Leuria:
+ * - `availability()`: "available" once the site is connected,
+ *   "downloadable" while it isn't (connecting is the "download": it needs
+ *   a click, like a model download), "unavailable" without Leuria.
+ * - `create()` from a click connects the site, reporting `downloadprogress`
+ *   0 then 1. The AI session itself starts with the first prompt.
+ * - Each `LanguageModel` is one session of the visitor's AI, which keeps
+ *   the context: a prompt sends only what's new.
+ * - `tools` run in the page, called by the visitor's AI.
+ * - `responseConstraint` is given to the AI as an instruction and checked
+ *   here; a mismatch goes back to the AI to fix.
+ * - Token counts are estimates (about 4 characters per token).
+ */
+
+type Availability = "unavailable" | "downloadable" | "downloading" | "available";
+type LanguageModelSamplingMode = "most-predictable" | "predictable" | "slightly-predictable" | "balanced" | "slightly-creative" | "creative" | "most-creative";
+interface LanguageModelExpected {
+    type: LanguageModelMessageType;
+    languages?: string[];
+}
+interface LanguageModelTool {
+    name: string;
+    description: string;
+    /** JSON Schema of the arguments. */
+    inputSchema: object;
+    /** Called with the arguments object; its result goes back to the model. */
+    execute: (...args: any[]) => Promise<string> | string;
+}
+interface LanguageModelCreateCoreOptions {
+    /** Accepted and ignored: the visitor's AI sets its own sampling. */
+    topK?: number;
+    /** Accepted and ignored: the visitor's AI sets its own sampling. */
+    temperature?: number;
+    /** Accepted and ignored: the visitor's AI sets its own sampling. */
+    samplingMode?: LanguageModelSamplingMode;
+    expectedInputs?: LanguageModelExpected[];
+    expectedOutputs?: LanguageModelExpected[];
+    tools?: LanguageModelTool[];
+}
+interface LanguageModelCreateOptions extends LanguageModelCreateCoreOptions {
+    signal?: AbortSignal;
+    monitor?: (monitor: EventTarget) => void;
+    initialPrompts?: LanguageModelMessage[];
+}
+interface LanguageModelPromptOptions {
+    responseConstraint?: ResponseConstraint;
+    /** Accepted and ignored: the visitor's AI always needs the constraint in its prompt. */
+    omitResponseConstraintInput?: boolean;
+    signal?: AbortSignal;
+}
+interface LanguageModelAppendOptions {
+    signal?: AbortSignal;
+}
+interface LanguageModelCloneOptions {
+    signal?: AbortSignal;
+}
+interface PromptAPIOptions extends BridgeProviderOptions {
+    /** The AI behind `LanguageModel`. Default: `leuria()` with these options. */
+    provider?: Provider;
+    /** Instructions for the AI when the page gives no system prompt. */
+    system?: string;
+    /** Most tool calls per prompt. Default 20. */
+    maxSteps?: number;
+    /** How many times an answer that misses the `responseConstraint` goes back to the AI. Default 2. */
+    retries?: number;
+}
+/** @internal What a `LanguageModel` starts from (its constructor is not public). */
+interface LanguageModelInit {
+    options: LanguageModelCreateCoreOptions;
+    system: string;
+    history: Message[];
+}
+/** Set on Leuria's `LanguageModel`, so code can tell it from the browser's own. */
+declare const LEURIA_MARK: unique symbol;
+declare function createLanguageModel(options?: PromptAPIOptions): {
+    new (token: symbol, init: LanguageModelInit): {
+        readonly "__#private@#options": LanguageModelCreateCoreOptions;
+        readonly "__#private@#system": string;
+        readonly "__#private@#tools": Map<string, LanguageModelTool>;
+        readonly "__#private@#history": Message[];
+        /** Appended messages, sent with the next prompt. */
+        "__#private@#pending": Message[];
+        "__#private@#session": ProviderSession | null;
+        "__#private@#queue": Promise<unknown>;
+        "__#private@#destroyed": boolean;
+        readonly "__#private@#lifetime": AbortController;
+        "__#private@#overflow": ((event: Event) => void) | null;
+        get contextUsage(): number;
+        get contextWindow(): number;
+        get samplingMode(): LanguageModelSamplingMode | null;
+        get oncontextoverflow(): ((event: Event) => void) | null;
+        set oncontextoverflow(handler: ((event: Event) => void) | null);
+        prompt(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): Promise<string>;
+        promptStreaming(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): ReadableStream<string>;
+        append(input: LanguageModelPrompt, options?: LanguageModelAppendOptions): Promise<void>;
+        measureContextUsage(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): Promise<number>;
+        clone(options?: LanguageModelCloneOptions): Promise</*elided*/ any>;
+        destroy(): void;
+        "__#private@#prompt"(input: LanguageModelPrompt, options: LanguageModelPromptOptions, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#turn"(messages: Message[], prefix: string | undefined, constraint: ResponseConstraint | undefined, signal: AbortSignal, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#send"(session: ProviderSession, message: Message, signal: AbortSignal, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#runTool"(name: string, args: Record<string, unknown>): Promise<{
+            ok: false;
+            error: string;
+            result?: undefined;
+        } | {
+            ok: true;
+            result: string;
+            error?: undefined;
+        }>;
+        "__#private@#ensureSession"(): Promise<ProviderSession>;
+        "__#private@#dropSession"(): void;
+        "__#private@#assertLive"(): void;
+        addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+        dispatchEvent(event: Event): boolean;
+        removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    };
+    availability(options?: LanguageModelCreateCoreOptions): Promise<Availability>;
+    /** Only in extension contexts in the spec; null here. */
+    params(): Promise<null>;
+    create(options?: LanguageModelCreateOptions): Promise<{
+        readonly "__#private@#options": LanguageModelCreateCoreOptions;
+        readonly "__#private@#system": string;
+        readonly "__#private@#tools": Map<string, LanguageModelTool>;
+        readonly "__#private@#history": Message[];
+        /** Appended messages, sent with the next prompt. */
+        "__#private@#pending": Message[];
+        "__#private@#session": ProviderSession | null;
+        "__#private@#queue": Promise<unknown>;
+        "__#private@#destroyed": boolean;
+        readonly "__#private@#lifetime": AbortController;
+        "__#private@#overflow": ((event: Event) => void) | null;
+        get contextUsage(): number;
+        get contextWindow(): number;
+        get samplingMode(): LanguageModelSamplingMode | null;
+        get oncontextoverflow(): ((event: Event) => void) | null;
+        set oncontextoverflow(handler: ((event: Event) => void) | null);
+        prompt(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): Promise<string>;
+        promptStreaming(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): ReadableStream<string>;
+        append(input: LanguageModelPrompt, options?: LanguageModelAppendOptions): Promise<void>;
+        measureContextUsage(input: LanguageModelPrompt, options?: LanguageModelPromptOptions): Promise<number>;
+        clone(options?: LanguageModelCloneOptions): Promise</*elided*/ any>;
+        destroy(): void;
+        "__#private@#prompt"(input: LanguageModelPrompt, options: LanguageModelPromptOptions, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#turn"(messages: Message[], prefix: string | undefined, constraint: ResponseConstraint | undefined, signal: AbortSignal, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#send"(session: ProviderSession, message: Message, signal: AbortSignal, onDelta?: (delta: string) => void): Promise<string>;
+        "__#private@#runTool"(name: string, args: Record<string, unknown>): Promise<{
+            ok: false;
+            error: string;
+            result?: undefined;
+        } | {
+            ok: true;
+            result: string;
+            error?: undefined;
+        }>;
+        "__#private@#ensureSession"(): Promise<ProviderSession>;
+        "__#private@#dropSession"(): void;
+        "__#private@#assertLive"(): void;
+        addEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+        dispatchEvent(event: Event): boolean;
+        removeEventListener(type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+    }>;
+    readonly [LEURIA_MARK]: true;
+};
+type LanguageModelConstructor = ReturnType<typeof createLanguageModel>;
+type LanguageModel = InstanceType<LanguageModelConstructor>;
+
+/**
+ * @leuria/prompt-api: the Prompt API (`LanguageModel`) where the browser
+ * can't run it, served by the visitor's own AI through Leuria.
+ *
+ *   import { installPromptAPI } from "@leuria/prompt-api"
+ *
+ *   await installPromptAPI({ app: "My notes" })
+ *   if ((await LanguageModel.availability()) !== "unavailable") {
+ *     const session = await LanguageModel.create()   // from a click, the first time
+ *     console.log(await session.prompt("Summarize this note: …"))
+ *   }
+ */
+
+interface InstallOptions extends PromptAPIOptions {
+    /**
+     * When Leuria provides `LanguageModel`:
+     * - `"unavailable"` (default): where the browser has none, or has one
+     *   that can't run on this device. The browser's own model is used
+     *   wherever it can run, even if it must download first.
+     * - `"missing"`: only where the browser has none.
+     * - `"always"`: always, in place of the browser's.
+     */
+    when?: "unavailable" | "missing" | "always";
+}
+/**
+ * Define `globalThis.LanguageModel` with Leuria, unless the browser's own
+ * model serves (see `when`). Resolves with who answers: `"browser"` or
+ * `"leuria"`.
+ */
+declare function installPromptAPI(options?: InstallOptions): Promise<"browser" | "leuria">;
+
+export { type Availability, type InstallOptions, LEURIA_MARK, type LanguageModel, type LanguageModelAppendOptions, type LanguageModelCloneOptions, type LanguageModelConstructor, type LanguageModelCreateCoreOptions, type LanguageModelCreateOptions, type LanguageModelExpected, type LanguageModelMessage, type LanguageModelMessageContent, type LanguageModelMessageRole, type LanguageModelMessageType, type LanguageModelPrompt, type LanguageModelPromptOptions, type LanguageModelSamplingMode, type LanguageModelTool, type PromptAPIOptions, type ResponseConstraint, createLanguageModel, installPromptAPI };

package/dist/index.js

@@ -0,0 +1,639 @@
+// src/language-model.ts
+import {
+  leuria,
+  messageText as messageText2,
+  newId as newId2
+} from "@leuria/client";
+
+// src/constraint.ts
+import { extractJson } from "@leuria/client";
+function constraintInstruction(constraint) {
+  if (constraint instanceof RegExp) {
+    return `Answer with text that matches this regular expression, and nothing else: ${constraint.toString()}`;
+  }
+  return `Answer with JSON only (no code fences, no other text), matching this JSON Schema:
+${JSON.stringify(constraint)}`;
+}
+function checkAnswer(text, constraint) {
+  if (constraint instanceof RegExp) {
+    const whole = new RegExp(`^(?:${constraint.source})$`, constraint.flags.replace(/[gy]/g, ""));
+    for (const candidate of [text, text.trim(), unfence(text.trim())]) {
+      if (whole.test(candidate)) return { ok: true, text: candidate };
+    }
+    return { ok: false, error: `the answer does not match ${constraint.toString()}` };
+  }
+  const value = extractJson(text);
+  if (value === void 0) return { ok: false, error: "the answer is not JSON" };
+  const error = validate(value, constraint, "$");
+  return error ? { ok: false, error } : { ok: true, text: JSON.stringify(value) };
+}
+function unfence(text) {
+  return /^```\w*\s*([\s\S]*?)\s*```$/.exec(text)?.[1] ?? text.replace(/^"([\s\S]*)"$/, "$1");
+}
+function validate(value, schema, path) {
+  if (typeof schema !== "object" || schema === null) return null;
+  if ("const" in schema && JSON.stringify(value) !== JSON.stringify(schema.const)) return `${path} must be ${JSON.stringify(schema.const)}`;
+  if (Array.isArray(schema.enum) && !schema.enum.some((e) => JSON.stringify(e) === JSON.stringify(value))) {
+    return `${path} must be one of ${JSON.stringify(schema.enum)}`;
+  }
+  for (const key of ["anyOf", "oneOf"]) {
+    const options = schema[key];
+    if (Array.isArray(options)) {
+      const matches = options.filter((s) => validate(value, s, path) === null).length;
+      if (matches === 0 || key === "oneOf" && matches > 1) return `${path} does not match ${key}`;
+    }
+  }
+  if (Array.isArray(schema.allOf)) {
+    for (const s of schema.allOf) {
+      const error = validate(value, s, path);
+      if (error) return error;
+    }
+  }
+  const types = schema.type === void 0 ? void 0 : [schema.type].flat();
+  if (types && !types.some((t) => isType(value, t))) return `${path} must be ${types.join(" or ")}`;
+  if (typeof value === "string") {
+    if (typeof schema.minLength === "number" && value.length < schema.minLength) return `${path} is too short`;
+    if (typeof schema.maxLength === "number" && value.length > schema.maxLength) return `${path} is too long`;
+    if (typeof schema.pattern === "string" && !new RegExp(schema.pattern, "u").test(value)) return `${path} must match ${schema.pattern}`;
+  }
+  if (typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) return `${path} must be at least ${schema.minimum}`;
+    if (typeof schema.maximum === "number" && value > schema.maximum) return `${path} must be at most ${schema.maximum}`;
+    if (typeof schema.exclusiveMinimum === "number" && value <= schema.exclusiveMinimum) return `${path} must be more than ${schema.exclusiveMinimum}`;
+    if (typeof schema.exclusiveMaximum === "number" && value >= schema.exclusiveMaximum) return `${path} must be less than ${schema.exclusiveMaximum}`;
+  }
+  if (Array.isArray(value)) {
+    if (typeof schema.minItems === "number" && value.length < schema.minItems) return `${path} needs at least ${schema.minItems} items`;
+    if (typeof schema.maxItems === "number" && value.length > schema.maxItems) return `${path} has more than ${schema.maxItems} items`;
+    if (schema.items && typeof schema.items === "object" && !Array.isArray(schema.items)) {
+      for (const [i, item] of value.entries()) {
+        const error = validate(item, schema.items, `${path}[${i}]`);
+        if (error) return error;
+      }
+    }
+  }
+  if (isType(value, "object")) {
+    const object = value;
+    const properties = schema.properties ?? {};
+    for (const key of Array.isArray(schema.required) ? schema.required : []) {
+      if (!(key in object)) return `${path}.${key} is required`;
+    }
+    for (const [key, item] of Object.entries(object)) {
+      if (key in properties) {
+        const error = validate(item, properties[key], `${path}.${key}`);
+        if (error) return error;
+      } else if (schema.additionalProperties === false) {
+        return `${path}.${key} is not allowed`;
+      } else if (typeof schema.additionalProperties === "object" && schema.additionalProperties !== null) {
+        const error = validate(item, schema.additionalProperties, `${path}.${key}`);
+        if (error) return error;
+      }
+    }
+  }
+  return null;
+}
+function isType(value, type) {
+  switch (type) {
+    case "string":
+      return typeof value === "string";
+    case "number":
+      return typeof value === "number" && Number.isFinite(value);
+    case "integer":
+      return Number.isInteger(value);
+    case "boolean":
+      return typeof value === "boolean";
+    case "null":
+      return value === null;
+    case "array":
+      return Array.isArray(value);
+    case "object":
+      return typeof value === "object" && value !== null && !Array.isArray(value);
+    default:
+      return true;
+  }
+}
+
+// src/content.ts
+import { messageFiles, messageText, newId } from "@leuria/client";
+
+// src/errors.ts
+function domError(name, message) {
+  if (typeof DOMException !== "undefined") return new DOMException(message, name);
+  const error = new Error(message);
+  error.name = name;
+  return error;
+}
+function abortReason(signal) {
+  return signal.reason ?? domError("AbortError", "The operation was aborted.");
+}
+
+// src/content.ts
+async function convert(input, initial = false) {
+  if (typeof input === "string") return { system: "", messages: [userText(input)] };
+  if (!Array.isArray(input)) throw new TypeError("The prompt must be a string or an array of messages.");
+  const system = [];
+  const messages = [];
+  let prefix;
+  for (const [index, message] of input.entries()) {
+    if (message.role === "system") {
+      if (!initial) throw domError("NotSupportedError", "System messages can only be given in initialPrompts.");
+      if (index !== 0) throw new TypeError("A system message must come first in initialPrompts.");
+    } else if (message.role !== "user" && message.role !== "assistant") {
+      throw new TypeError(`Unknown role: ${String(message.role)}`);
+    }
+    if (message.prefix) {
+      if (message.role !== "assistant" || index !== input.length - 1 || initial) {
+        throw domError("SyntaxError", "Only the last message, from the assistant, can be a prefix.");
+      }
+    }
+    const parts = await toParts(message.content);
+    if (message.role === "system") {
+      system.push(textOf(parts));
+    } else if (message.prefix) {
+      prefix = textOf(parts);
+    } else {
+      messages.push({ id: newId(), role: message.role, parts });
+    }
+  }
+  return { system: system.join("\n\n"), messages, prefix };
+}
+function userText(text) {
+  return { id: newId(), role: "user", parts: [{ type: "text", text }] };
+}
+function textOf(parts) {
+  return messageText({ id: "", role: "user", parts });
+}
+async function toParts(content) {
+  if (typeof content === "string") return [{ type: "text", text: content }];
+  if (!Array.isArray(content)) throw new TypeError("A message's content must be a string or an array.");
+  const parts = [];
+  for (const item of content) {
+    switch (item.type) {
+      case "text":
+        if (typeof item.value !== "string") throw new TypeError("A text content's value must be a string.");
+        parts.push({ type: "text", text: item.value });
+        break;
+      case "image":
+        parts.push({ type: "file", ...await imageData(item.value) });
+        break;
+      case "audio":
+        throw domError("NotSupportedError", "Audio input is not supported.");
+      case "tool-call":
+      case "tool-response":
+        parts.push({ type: "text", text: `[${item.type}] ${typeof item.value === "string" ? item.value : JSON.stringify(item.value)}` });
+        break;
+      default:
+        throw new TypeError(`Unknown content type: ${String(item.type)}`);
+    }
+  }
+  return parts;
+}
+function asOneTurn(messages) {
+  if (messages.length === 1 && messages[0].role === "user") return messages[0];
+  const text = messages.map((m) => `${m.role === "user" ? "User" : "Assistant"}: ${messageText(m)}`).join("\n\n");
+  return { id: newId(), role: "user", parts: [{ type: "text", text }, ...messages.flatMap(messageFiles)] };
+}
+async function imageData(value) {
+  if (typeof Blob !== "undefined" && value instanceof Blob) {
+    const bytes = new Uint8Array(await value.arrayBuffer());
+    return encode(bytes, value.type || sniff(bytes));
+  }
+  if (value instanceof ArrayBuffer || ArrayBuffer.isView(value)) {
+    const bytes = value instanceof ArrayBuffer ? new Uint8Array(value) : new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    return encode(bytes, sniff(bytes));
+  }
+  if (value && typeof value === "object") return encode(await drawToPng(value), "image/png");
+  throw new TypeError("An image's value must be an image, a canvas, a Blob or bytes.");
+}
+function encode(bytes, mediaType) {
+  if (!mediaType.startsWith("image/")) throw domError("NotSupportedError", "This image format is not supported.");
+  let binary = "";
+  for (let i = 0; i < bytes.length; i += 32768) binary += String.fromCharCode(...bytes.subarray(i, i + 32768));
+  return { mediaType, url: `data:${mediaType};base64,${btoa(binary)}` };
+}
+function sniff(bytes) {
+  const starts = (...sig) => sig.every((b, i) => bytes[i] === b);
+  if (starts(137, 80, 78, 71)) return "image/png";
+  if (starts(255, 216, 255)) return "image/jpeg";
+  if (starts(71, 73, 70, 56)) return "image/gif";
+  if (starts(82, 73, 70, 70) && bytes[8] === 87 && bytes[9] === 69 && bytes[10] === 66 && bytes[11] === 80) return "image/webp";
+  return "application/octet-stream";
+}
+async function drawToPng(source) {
+  if (typeof HTMLImageElement !== "undefined" && source instanceof HTMLImageElement && !source.complete) await source.decode();
+  const isData = typeof ImageData !== "undefined" && source instanceof ImageData;
+  const size = source;
+  const width = size.naturalWidth || size.videoWidth || size.displayWidth || size.width || 0;
+  const height = size.naturalHeight || size.videoHeight || size.displayHeight || size.height || 0;
+  if (!width || !height) throw domError("InvalidStateError", "The image has no size (not loaded yet?).");
+  let blob;
+  if (typeof OffscreenCanvas !== "undefined") {
+    const canvas = new OffscreenCanvas(width, height);
+    const ctx = canvas.getContext("2d");
+    if (isData) ctx.putImageData(source, 0, 0);
+    else ctx.drawImage(source, 0, 0);
+    blob = await canvas.convertToBlob({ type: "image/png" });
+  } else if (typeof document !== "undefined") {
+    const canvas = document.createElement("canvas");
+    canvas.width = width;
+    canvas.height = height;
+    const ctx = canvas.getContext("2d");
+    if (isData) ctx.putImageData(source, 0, 0);
+    else ctx.drawImage(source, 0, 0);
+    blob = await new Promise((resolve, reject) => canvas.toBlob((b) => b ? resolve(b) : reject(domError("InvalidStateError", "The image could not be read.")), "image/png"));
+  } else {
+    throw domError("NotSupportedError", "Images need a browser.");
+  }
+  return new Uint8Array(await blob.arrayBuffer());
+}
+
+// src/language-model.ts
+var LEURIA_MARK = /* @__PURE__ */ Symbol.for("leuria.prompt-api");
+var DEFAULT_SYSTEM = "You answer requests from a web page. Reply with the answer only, without preamble or follow-up questions. Use only the tools the page gives you, if any.";
+var CONTEXT_WINDOW = 128e3;
+var estimateTokens = (text) => Math.ceil(text.length / 4);
+function createLanguageModel(options = {}) {
+  const { provider: given, system: defaultSystem = DEFAULT_SYSTEM, maxSteps = 20, retries = 2, ...bridgeOptions } = options;
+  let shared = given;
+  const provider = () => shared ??= leuria(bridgeOptions);
+  const key = /* @__PURE__ */ Symbol("LanguageModel");
+  const live = /* @__PURE__ */ new Set();
+  let watching = false;
+  const watchUnload = () => {
+    if (watching || typeof window === "undefined") return;
+    watching = true;
+    window.addEventListener("pagehide", () => {
+      for (const model of [...live]) model.destroy();
+    });
+  };
+  class LanguageModel extends EventTarget {
+    static [LEURIA_MARK] = true;
+    static async availability(options2 = {}) {
+      validateCore(options2);
+      return availabilityOf(provider(), options2);
+    }
+    /** Only in extension contexts in the spec; null here. */
+    static async params() {
+      return null;
+    }
+    static async create(options2 = {}) {
+      validateCore(options2);
+      const { signal } = options2;
+      if (signal?.aborted) throw abortReason(signal);
+      const initial = await convert(options2.initialPrompts ?? [], true);
+      const ai = provider();
+      let availability = await availabilityOf(ai, options2);
+      if (availability === "unavailable") throw domError("NotSupportedError", "No AI can serve these options here.");
+      const monitor = new EventTarget();
+      options2.monitor?.(monitor);
+      if (availability !== "available") {
+        if (!hasActivation()) {
+          throw domError("NotAllowedError", "Connecting the visitor's AI needs a user gesture: call create() from a click.");
+        }
+        if (!ai.connect) throw domError("NotSupportedError", "This AI cannot be connected from the page.");
+        progress(monitor, 0);
+        await untilAborted(ai.connect(), signal);
+        availability = await availabilityOf(ai, options2);
+        if (availability !== "available") throw domError("NotAllowedError", "The visitor's AI was not connected.");
+        progress(monitor, 1);
+      }
+      if (signal?.aborted) throw abortReason(signal);
+      const { signal: _signal, monitor: _monitor, initialPrompts: _initial, ...core } = options2;
+      return new LanguageModel(key, { options: core, system: initial.system || defaultSystem, history: initial.messages });
+    }
+    #options;
+    #system;
+    #tools;
+    #history;
+    /** Appended messages, sent with the next prompt. */
+    #pending = [];
+    #session = null;
+    #queue = Promise.resolve();
+    #destroyed = false;
+    #lifetime = new AbortController();
+    #overflow = null;
+    constructor(token, init) {
+      if (token !== key) throw new TypeError("Illegal constructor");
+      super();
+      this.#options = init.options;
+      this.#system = init.system;
+      this.#history = [...init.history];
+      this.#tools = new Map((init.options.tools ?? []).map((tool) => [tool.name, tool]));
+      live.add(this);
+      watchUnload();
+    }
+    get contextUsage() {
+      return estimateTokens([this.#system, ...[...this.#history, ...this.#pending].map(messageText2)].join("\n"));
+    }
+    get contextWindow() {
+      return CONTEXT_WINDOW;
+    }
+    get samplingMode() {
+      return this.#options.samplingMode ?? null;
+    }
+    get oncontextoverflow() {
+      return this.#overflow;
+    }
+    set oncontextoverflow(handler) {
+      if (this.#overflow) this.removeEventListener("contextoverflow", this.#overflow);
+      this.#overflow = typeof handler === "function" ? handler : null;
+      if (this.#overflow) this.addEventListener("contextoverflow", this.#overflow);
+    }
+    prompt(input, options2 = {}) {
+      return this.#prompt(input, options2);
+    }
+    promptStreaming(input, options2 = {}) {
+      const cancel = new AbortController();
+      const stream = new ReadableStream({
+        start: (controller) => {
+          const enqueue = (delta) => {
+            try {
+              controller.enqueue(delta);
+            } catch {
+            }
+          };
+          this.#prompt(input, { ...options2, signal: anySignal(options2.signal, cancel.signal) }, enqueue).then(
+            () => controller.close(),
+            (error) => {
+              try {
+                controller.error(error);
+              } catch {
+              }
+            }
+          );
+        },
+        cancel: (reason) => cancel.abort(reason ?? domError("AbortError", "The stream was cancelled."))
+      });
+      return asyncIterable(stream);
+    }
+    async append(input, options2 = {}) {
+      this.#assertLive();
+      const signal = anySignal(options2.signal, this.#lifetime.signal);
+      if (signal.aborted) throw abortReason(signal);
+      const { messages, prefix } = await convert(input);
+      if (prefix !== void 0) throw domError("SyntaxError", "append() takes no prefix message.");
+      const work = this.#queue.then(() => {
+        if (signal.aborted) throw abortReason(signal);
+        this.#pending.push(...messages);
+      });
+      this.#queue = work.catch(() => void 0);
+      return untilAborted(work, signal);
+    }
+    async measureContextUsage(input, options2 = {}) {
+      this.#assertLive();
+      const { messages, prefix } = await convert(input);
+      const constraint = options2.responseConstraint ? constraintInstruction(options2.responseConstraint) : "";
+      return estimateTokens([...messages.map(messageText2), prefix ?? "", constraint].join("\n"));
+    }
+    async clone(options2 = {}) {
+      this.#assertLive();
+      const signal = anySignal(options2.signal, this.#lifetime.signal);
+      await untilAborted(this.#queue, signal);
+      this.#assertLive();
+      return new LanguageModel(key, { options: this.#options, system: this.#system, history: [...this.#history, ...this.#pending] });
+    }
+    destroy() {
+      if (this.#destroyed) return;
+      this.#destroyed = true;
+      this.#lifetime.abort(domError("AbortError", "The session was destroyed."));
+      this.#dropSession();
+      live.delete(this);
+    }
+    // ── Turns ───────────────────────────────────────────────────────
+    async #prompt(input, options2, onDelta) {
+      this.#assertLive();
+      const signal = anySignal(options2.signal, this.#lifetime.signal);
+      if (signal.aborted) throw abortReason(signal);
+      const constraint = options2.responseConstraint;
+      if (constraint !== void 0 && (typeof constraint !== "object" || constraint === null)) {
+        throw new TypeError("responseConstraint must be a JSON Schema or a RegExp.");
+      }
+      const { messages, prefix } = await convert(input);
+      const work = this.#queue.then(() => this.#turn(messages, prefix, constraint, signal, onDelta));
+      this.#queue = work.catch(() => void 0);
+      return untilAborted(work, signal);
+    }
+    async #turn(messages, prefix, constraint, signal, onDelta) {
+      if (signal.aborted) throw abortReason(signal);
+      const sending = [...this.#pending, ...messages];
+      const user = asOneTurn(sending.length ? sending : [{ id: newId2(), role: "user", parts: [{ type: "text", text: "" }] }]);
+      const hasImages = user.parts.some((p) => p.type === "file" && p.mediaType.startsWith("image/"));
+      if (hasImages && !provider().getState().capabilities.includes("images")) {
+        throw domError("NotSupportedError", "The visitor's AI does not take images.");
+      }
+      const instructions = [
+        constraint ? constraintInstruction(constraint) : void 0,
+        prefix !== void 0 ? `Begin your answer with exactly this text, then continue it:
+${prefix}` : void 0
+      ].filter((s) => Boolean(s));
+      const session = await this.#ensureSession();
+      let answer;
+      if (constraint) {
+        let text = await this.#send(session, withInstructions(user, instructions), signal);
+        let check = checkAnswer(stripPrefix(text, prefix), constraint);
+        for (let attempt = 0; !check.ok && attempt < retries; attempt++) {
+          const fix = `That answer is not valid: ${check.error}. ${constraintInstruction(constraint)}`;
+          text = await this.#send(session, { id: newId2(), role: "user", parts: [{ type: "text", text: fix }] }, signal);
+          check = checkAnswer(stripPrefix(text, prefix), constraint);
+        }
+        if (!check.ok) throw domError("UnknownError", `The answer did not match the response constraint: ${check.error}.`);
+        answer = check.text;
+        if (answer) onDelta?.(answer);
+      } else {
+        const strip = prefixStripper(prefix, onDelta);
+        const text = await this.#send(session, withInstructions(user, instructions), signal, strip.push);
+        strip.flush();
+        answer = stripPrefix(text, prefix);
+      }
+      this.#pending = [];
+      this.#history.push(user, { id: newId2(), role: "assistant", parts: [{ type: "text", text: (prefix ?? "") + answer }] });
+      return answer;
+    }
+    async #send(session, message, signal, onDelta) {
+      const context = {
+        turnId: newId2("turn"),
+        signal,
+        text: (delta) => {
+          if (delta && !signal.aborted) onDelta?.(delta);
+        },
+        reasoning: () => void 0,
+        status: () => void 0,
+        runTool: ({ name, args }) => this.#runTool(name, args)
+      };
+      try {
+        return (await session.send(message, context)).text;
+      } catch (error) {
+        if (signal.aborted) throw abortReason(signal);
+        this.#dropSession();
+        throw domError("UnknownError", error instanceof Error ? error.message : String(error));
+      }
+    }
+    async #runTool(name, args) {
+      const tool = this.#tools.get(name);
+      if (!tool) return { ok: false, error: `Unknown tool: ${name}` };
+      try {
+        const result = await tool.execute(args);
+        return { ok: true, result: typeof result === "string" ? result : JSON.stringify(result ?? null) };
+      } catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+      }
+    }
+    async #ensureSession() {
+      if (this.#session && !this.#session.closed) return this.#session;
+      this.#dropSession();
+      const ai = provider();
+      if (ai.getState().status !== "ready") await ai.detect().catch(() => void 0);
+      const state = ai.getState();
+      if (state.status !== "ready") throw domError("InvalidStateError", "The visitor's AI is not connected anymore.");
+      const tools = [...this.#tools.values()].map(({ name, description, inputSchema }) => ({
+        name,
+        description,
+        inputSchema
+      }));
+      if (tools.length && !state.capabilities.includes("tools")) throw domError("NotSupportedError", "The visitor's AI cannot use tools.");
+      this.#session = await ai.createSession({ system: this.#system, tools, history: [...this.#history], maxSteps });
+      return this.#session;
+    }
+    #dropSession() {
+      try {
+        this.#session?.close();
+      } catch {
+      }
+      this.#session = null;
+    }
+    #assertLive() {
+      if (this.#destroyed) throw domError("InvalidStateError", "The session was destroyed.");
+    }
+  }
+  return LanguageModel;
+}
+function validateCore(options) {
+  if (options.samplingMode !== void 0 && (options.topK !== void 0 || options.temperature !== void 0)) {
+    throw new TypeError("samplingMode cannot be combined with topK or temperature.");
+  }
+  for (const expected of [...options.expectedInputs ?? [], ...options.expectedOutputs ?? []]) {
+    if (expected.languages) Intl.getCanonicalLocales(expected.languages);
+  }
+}
+async function availabilityOf(ai, options) {
+  const inputs = (options.expectedInputs ?? []).map((e) => e.type);
+  const outputs = (options.expectedOutputs ?? []).map((e) => e.type);
+  if (inputs.includes("audio") || outputs.some((t) => t !== "text" && t !== "tool-call")) return "unavailable";
+  await ai.detect().catch(() => void 0);
+  const state = ai.getState();
+  const caps = new Set(state.capabilities);
+  if (inputs.includes("image") && !caps.has("images")) return "unavailable";
+  if (options.tools?.length && !caps.has("tools")) return "unavailable";
+  switch (state.status) {
+    case "ready":
+      return "available";
+    case "needs-action":
+      return "downloadable";
+    case "downloading":
+      return "downloading";
+    default:
+      return "unavailable";
+  }
+}
+function hasActivation() {
+  const activation = typeof navigator === "undefined" ? void 0 : navigator.userActivation;
+  return activation ? activation.isActive : true;
+}
+function progress(target, loaded) {
+  const event = typeof ProgressEvent !== "undefined" ? new ProgressEvent("downloadprogress", { loaded, total: 1 }) : Object.assign(new Event("downloadprogress"), { loaded, total: 1 });
+  target.dispatchEvent(event);
+}
+function withInstructions(message, instructions) {
+  if (!instructions.length) return message;
+  const text = [messageText2(message), ...instructions].filter(Boolean).join("\n\n");
+  return { ...message, parts: [{ type: "text", text }, ...message.parts.filter((p) => p.type !== "text")] };
+}
+function stripPrefix(text, prefix) {
+  if (!prefix) return text;
+  const start = text.trimStart();
+  return start.startsWith(prefix) ? start.slice(prefix.length) : text;
+}
+function prefixStripper(prefix, onDelta) {
+  if (!prefix) return { push: (delta) => onDelta?.(delta), flush: () => void 0 };
+  let buffer = "";
+  let decided = false;
+  return {
+    push(delta) {
+      if (decided) return onDelta?.(delta);
+      buffer += delta;
+      const start = buffer.trimStart();
+      if (start.length < prefix.length && prefix.startsWith(start)) return;
+      decided = true;
+      const rest = start.startsWith(prefix) ? start.slice(prefix.length) : buffer;
+      if (rest) onDelta?.(rest);
+    },
+    flush() {
+      if (!decided && !prefix.startsWith(buffer.trimStart())) onDelta?.(buffer);
+    }
+  };
+}
+function anySignal(...signals) {
+  const list = signals.filter((s) => Boolean(s));
+  if (list.length === 1) return list[0];
+  if (typeof AbortSignal.any === "function") return AbortSignal.any(list);
+  const controller = new AbortController();
+  for (const signal of list) {
+    if (signal.aborted) {
+      controller.abort(signal.reason);
+      break;
+    }
+    signal.addEventListener("abort", () => controller.abort(signal.reason), { once: true });
+  }
+  return controller.signal;
+}
+function untilAborted(promise, signal) {
+  if (!signal) return promise;
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function asyncIterable(stream) {
+  if (Symbol.asyncIterator in stream) return stream;
+  Object.defineProperty(stream, Symbol.asyncIterator, {
+    value: async function* () {
+      const reader = stream.getReader();
+      try {
+        for (; ; ) {
+          const { value, done } = await reader.read();
+          if (done) return;
+          yield value;
+        }
+      } finally {
+        reader.releaseLock();
+      }
+    }
+  });
+  return stream;
+}
+
+// src/index.ts
+async function installPromptAPI(options = {}) {
+  const { when = "unavailable", ...rest } = options;
+  const scope = globalThis;
+  const native = scope.LanguageModel;
+  if (native && !native[LEURIA_MARK] && when !== "always") {
+    if (when === "missing") return "browser";
+    const availability = await Promise.resolve(native.availability?.()).catch(() => "unavailable");
+    if (availability !== "unavailable") return "browser";
+  }
+  Object.defineProperty(globalThis, "LanguageModel", {
+    value: createLanguageModel(rest),
+    writable: true,
+    configurable: true,
+    enumerable: false
+  });
+  return "leuria";
+}
+export {
+  LEURIA_MARK,
+  createLanguageModel,
+  installPromptAPI
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@leuria/prompt-api",
+  "version": "0.1.0",
+  "description": "The Prompt API (LanguageModel) in every browser, served by the visitor's own AI through Leuria when the browser has no built-in model.",
+  "license": "Apache-2.0",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leur-ia/leuria.git",
+    "directory": "packages/prompt-api"
+  },
+  "homepage": "https://leuria.dev",
+  "keywords": [
+    "prompt-api",
+    "LanguageModel",
+    "polyfill",
+    "built-in-ai",
+    "web-ai"
+  ],
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "sideEffects": false,
+  "dependencies": {
+    "@leuria/client": "^0.1.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.4.0",
+    "typescript": "^5.9.0",
+    "vitest": "^3.2.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "check": "tsc --noEmit && tsc -p test",
+    "test": "vitest run"
+  }
+}