@tanstack-ai-browser/prompt-api 0.0.0-stage → 0.2.0

package/src/model.ts

@@ -0,0 +1,75 @@
+/**
+ * The browser's built-in model: whether this browser has one, and its
+ * sessions. The browser downloads the model once for all sites (Chrome
+ * keeps it in its profile) and loads it when a session is created.
+ */
+import { languageModel } from "./types.js"
+import type {
+  Availability,
+  DownloadProgressCallback,
+  DownloadProgressEvent,
+  LanguageModelCreateOptions,
+  LanguageModelSession
+} from "./types.js"
+
+export type { Availability, SamplingMode } from "./types.js"
+
+/** Kinds of input besides text a session can be told to expect. */
+export type MediaInput = "image" | "audio"
+
+/** Every kind of input besides text, in the order `availableInputModalities` asks. */
+export const MEDIA_INPUTS: ReadonlyArray<MediaInput> = ["image", "audio"]
+
+/** Languages the model is told to expect, in and out, by default. */
+export const DEFAULT_LANGUAGES = ["en"] as const
+
+/**
+ * What every session expects: text in and out in the languages given (Chrome
+ * checks its safety filters for the output language), and images or audio
+ * in if the conversation has them.
+ */
+export function baseOptions(
+  languages: ReadonlyArray<string> = DEFAULT_LANGUAGES,
+  media: ReadonlyArray<MediaInput> = []
+): LanguageModelCreateOptions {
+  return {
+    expectedInputs: [{ type: "text", languages: [...languages] }, ...media.map((type) => ({ type }))],
+    expectedOutputs: [{ type: "text", languages: [...languages] }]
+  }
+}
+
+/**
+ * Whether this browser can run its built-in model with these options:
+ * "available" (on the device), "downloadable" or "downloading" (it
+ * downloads when a session is created), or "unavailable".
+ */
+export async function promptApiAvailability(options: LanguageModelCreateOptions): Promise<Availability> {
+  return (await languageModel()?.availability(options)) ?? "unavailable"
+}
+
+/**
+ * A new session. `onDownloadProgress` hears a download, 0 to 1 (Chrome
+ * reports 0 and 1 on every create, so only the steps between are passed
+ * on), then 1 once the session has started. Aborting `signal` stops the
+ * create and destroys the session.
+ */
+export async function createSession(
+  options: LanguageModelCreateOptions,
+  signal?: AbortSignal,
+  onDownloadProgress?: DownloadProgressCallback
+): Promise<LanguageModelSession> {
+  const api = languageModel()
+  if (!api) throw new Error("This browser has no Prompt API (LanguageModel).")
+  const session = await api.create({
+    ...options,
+    ...(signal && { signal }),
+    monitor(monitor) {
+      monitor.addEventListener("downloadprogress", (event) => {
+        const { loaded } = event as DownloadProgressEvent
+        if (loaded > 0 && loaded < 1) onDownloadProgress?.(loaded)
+      })
+    }
+  })
+  onDownloadProgress?.(1)
+  return session
+}

package/src/tools.test.ts

@@ -0,0 +1,129 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+
+import {
+  parseToolCall,
+  toolCallFence,
+  toolCallReader,
+  toolResultFence,
+  toolResultLine,
+  toolSystemPrompt
+} from "./tools.js"
+
+const weather = {
+  name: "get_weather",
+  description: "Weather for a city",
+  inputSchema: { type: "object", properties: { city: { type: "string" } }, required: ["city"] }
+}
+
+/** What a reader shows for these pieces, and the call it read. */
+function read(pieces: Array<string>) {
+  const reader = toolCallReader()
+  let shown = ""
+  for (const piece of pieces) {
+    shown += reader.push(piece)
+    if (reader.call) break
+  }
+  shown += reader.end()
+  return { shown, call: reader.call }
+}
+
+test("the system prompt lists the tools as JSON after the caller's prompt, with the fence formats", () => {
+  const prompt = toolSystemPrompt("Be brief.", [weather, { name: "clock", description: "" }])
+  assert.ok(prompt.startsWith("Be brief.\n\nYou are a helpful AI assistant with access to tools.\n\n# Available Tools\n"))
+  const json = prompt.slice(prompt.indexOf("["), prompt.indexOf("\n]\n") + 2)
+  assert.deepEqual(JSON.parse(json), [
+    { name: "get_weather", description: "Weather for a city", parameters: weather.inputSchema },
+    { name: "clock", description: "", parameters: { type: "object", properties: {} } }
+  ])
+  assert.match(prompt, /```tool_call\n\{"name": "tool_name", "arguments": \{"param1": "value1", "param2": "value2"\}\}\n```/)
+  assert.match(prompt, /```tool_result\n\{"id": "call_123", "name": "tool_name", "result": \{\.\.\.\}, "error": false\}\n```/)
+  assert.match(prompt, /Only request one tool call at a time/)
+  assert.match(prompt, /If no tool is needed, respond directly without tool_call fences$/)
+  assert.equal(toolSystemPrompt("Be brief.", []), "Be brief.")
+  assert.ok(toolSystemPrompt("", [weather]).startsWith("You are a helpful AI assistant with access to tools."))
+})
+
+test("past calls and results are written in the fences the prompt describes", () => {
+  assert.equal(
+    toolCallFence([{ id: "c1", type: "function", function: { name: "get_weather", arguments: '{"city":"Paris"}' } }]),
+    '```tool_call\n{"name":"get_weather","arguments":{"city":"Paris"},"id":"c1"}\n```'
+  )
+  assert.equal(toolResultLine("c1", "get_weather", '{"temp":12}'), '{"name":"get_weather","result":{"temp":12},"error":false,"id":"c1"}')
+  assert.equal(toolResultLine("c1", "get_weather", "sunny"), '{"name":"get_weather","result":"sunny","error":false,"id":"c1"}')
+  assert.equal(toolResultLine("c1", "get_weather", "", "no such city"), '{"name":"get_weather","result":"no such city","error":true,"id":"c1"}')
+  assert.equal(toolResultFence(["a", "b"]), "```tool_result\na\nb\n```")
+})
+
+test("a call's JSON: arguments or parameters, a JSON-string argument, an array or lines; nothing else", () => {
+  assert.deepEqual(parseToolCall('{"name":"a","arguments":{"x":1}}'), { name: "a", arguments: { x: 1 } })
+  assert.deepEqual(parseToolCall('{"name":"a","parameters":{"x":1}}'), { name: "a", arguments: { x: 1 } })
+  assert.deepEqual(parseToolCall('{"name":"a","arguments":"{\\"x\\":1}"}'), { name: "a", arguments: { x: 1 } })
+  assert.deepEqual(parseToolCall('[{"name":"a"},{"name":"b"}]'), { name: "a", arguments: {} })
+  assert.deepEqual(parseToolCall('{"name":"a"}\n{"name":"b"}'), { name: "a", arguments: {} })
+  assert.equal(parseToolCall("not json"), undefined)
+  assert.equal(parseToolCall('{"arguments":{}}'), undefined)
+  assert.equal(parseToolCall('{"tool":"a","arguments":{}}'), undefined)
+})
+
+test("no call: all the text is shown", () => {
+  assert.deepEqual(read(["It's ", "sunny ", "today."]), { shown: "It's sunny today.", call: undefined })
+})
+
+test("a call split across pieces is held back and read; text before it is shown", () => {
+  const { shown, call } = read([
+    "Let me check. `",
+    "``tool",
+    '_call\n{"name": "get_',
+    'weather", "arguments": {"city": ',
+    '"Paris"}}\n`',
+    "``",
+    "Ignored after the call."
+  ])
+  assert.equal(shown, "Let me check. ")
+  assert.deepEqual(call, { name: "get_weather", arguments: { city: "Paris" } })
+})
+
+test("the tool-call spelling is read too", () => {
+  assert.deepEqual(read(['```tool-call\n{"name":"a","arguments":{}}\n```']).call, { name: "a", arguments: {} })
+})
+
+test("text after a closed fence, in the piece that closed it, is kept as trailing", () => {
+  const reader = toolCallReader()
+  assert.equal(reader.push('Checking.\n```tool_call\n{"name":"a","arguments":{}}\n``` Back soon.'), "Checking.\n")
+  assert.deepEqual(reader.call, { name: "a", arguments: {} })
+  assert.equal(reader.trailing, " Back soon.")
+})
+
+test("other ways small models write a call are read too: tags, delimiters, Python style and call:name{}", () => {
+  const weather = { name: "get_weather", arguments: { city: "Oslo" } }
+  assert.deepEqual(read(['<tool_call>{"name": "get_weather", "arguments": {"city": "Oslo"}}</tool_call>']).call, weather)
+  assert.deepEqual(read(['<|tool_call>call:get_weather{city:Oslo}<tool_call|>']).call, weather)
+  assert.deepEqual(read(['<|tool_call_start|>[get_weather(city="Oslo")]<|tool_call_end|>']).call, weather)
+  assert.deepEqual(read(['Sure. [get_weather(city=', '"Oslo")] ok']), { shown: "Sure. ", call: weather })
+  assert.deepEqual(
+    read(["[search(query='rain, today', limit=3, exact=True, tags=['a', 'b'], extra=None)]"]).call?.arguments,
+    { query: "rain, today", limit: 3, exact: true, tags: ["a", "b"], extra: null }
+  )
+  assert.deepEqual(read(["<|tool_call>call:get_weather{days:3,metric:true}<tool_call|>"]).call?.arguments, { days: 3, metric: true })
+})
+
+test("a fence without a call, an unclosed fence, bare JSON and other code fences are text", () => {
+  const reader = toolCallReader()
+  assert.equal(reader.push("Hm. ```tool_call\nnope\n``` then "), "Hm. ```tool_call\nnope\n``` then ")
+  assert.equal(reader.push('```tool_call\n{"name":"a"}\n```'), "")
+  assert.deepEqual(reader.call, { name: "a", arguments: {} })
+  assert.deepEqual(read(["```tool_call\n{broken"]), { shown: "```tool_call\n{broken", call: undefined })
+  assert.deepEqual(read(['{"name":"a","arguments":{}}']), { shown: '{"name":"a","arguments":{}}', call: undefined })
+  assert.deepEqual(read(["```js\nx()\n```"]), { shown: "```js\nx()\n```", call: undefined })
+  assert.deepEqual(read(["a ``", "`"]), { shown: "a ```", call: undefined })
+})
+
+test("a JSON call is read as JSON: call syntax in its string arguments is just text", () => {
+  for (const query of ["call:bogus{arg:value}", "[bogus(x=1)]", "bogus(x=1)"]) {
+    const body = JSON.stringify({ name: "search", arguments: { query } })
+    assert.deepEqual(parseToolCall(body), { name: "search", arguments: { query } })
+    assert.deepEqual(read(["```tool_call\n" + body + "\n```"]).call, { name: "search", arguments: { query } })
+  }
+  assert.equal(parseToolCall("see call:bogus{arg:value} here"), undefined, "the fallback syntax is the whole body")
+})

package/src/tools.ts

@@ -0,0 +1,311 @@
+/**
+ * Tool calls by prompt. Chrome's Prompt API has no
+ * working tool use on web pages (a session that expects tool calls fails to
+ * start, and `tools` alone are never called), so the system prompt lists the
+ * tools as JSON and asks for a call as JSON in a ```tool_call fence; results
+ * go back in a ```tool_result fence. The adapter reads calls out of the
+ * streamed text; `chat()` checks them against the tools.
+ */
+import type { ModelMessage, Tool } from "@tanstack/ai"
+
+/** A tool call read from the model's text. */
+export type ParsedToolCall = { name: string; arguments: unknown }
+
+/** Where a call starts and ends: the fence the prompt asks for, then other ways small models write one. */
+type Delimiter = { start: string; end: string }
+const DELIMITERS: Array<Delimiter> = [
+  { start: "```tool_call", end: "```" },
+  { start: "```tool-call", end: "```" },
+  { start: "<tool_call>", end: "</tool_call>" },
+  { start: "<|tool_call>", end: "<tool_call|>" },
+  { start: "<|tool_call_start|>", end: "<|tool_call_end|>" }
+]
+/** A Python-style call, `[name(...)]`. */
+const PYTHON_CALL = /\[(\w+)\(/
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value)
+
+/**
+ * The system prompt with the tools and how to call them; unchanged without
+ * tools.
+ */
+export function toolSystemPrompt(system: string, tools: ReadonlyArray<Tool>): string {
+  if (tools.length === 0) return system
+  const definitions = tools.map((tool) => ({
+    name: tool.name,
+    description: tool.description ?? "No description provided.",
+    parameters: tool.inputSchema ?? { type: "object", properties: {} }
+  }))
+  const instructions = `You are a helpful AI assistant with access to tools.
+
+# Available Tools
+${JSON.stringify(definitions, null, 2)}
+
+# Tool Calling Instructions
+Only request one tool call at a time. Wait for tool results before asking for another tool.
+
+To call a tool, output JSON in this exact format inside a \`\`\`tool_call code fence:
+
+\`\`\`tool_call
+{"name": "tool_name", "arguments": {"param1": "value1", "param2": "value2"}}
+\`\`\`
+
+Tool responses will be provided in \`\`\`tool_result fences. Each line contains JSON like:
+\`\`\`tool_result
+{"id": "call_123", "name": "tool_name", "result": {...}, "error": false}
+\`\`\`
+Use the \`result\` payload (and treat \`error\` as a boolean flag) when continuing the conversation.
+
+Important:
+- Use exact tool and parameter names from the schema above
+- Arguments must be a valid JSON object matching the tool's parameters
+- You can include brief reasoning before or after the tool call
+- If no tool is needed, respond directly without tool_call fences`
+  return system.trim() ? `${system.trim()}\n\n${instructions}` : instructions
+}
+
+/** Earlier tool calls in the conversation, as the model would have written them. */
+export function toolCallFence(calls: NonNullable<ModelMessage["toolCalls"]>): string {
+  const lines = calls.map((call) => {
+    let args: unknown
+    try {
+      args = JSON.parse(call.function.arguments || "{}")
+    } catch {
+      args = call.function.arguments
+    }
+    return JSON.stringify({ name: call.function.name, arguments: args, ...(call.id && { id: call.id }) })
+  })
+  return `\`\`\`tool_call\n${lines.join("\n")}\n\`\`\``
+}
+
+/** A tool's result line for a ```tool_result fence. */
+export function toolResultLine(id: string, name: string, content: string, error?: string): string {
+  let result: unknown = error ?? content
+  if (error === undefined) {
+    try {
+      result = JSON.parse(content)
+    } catch {
+      // Plain text.
+    }
+  }
+  return JSON.stringify({ name, result: result ?? null, error: error !== undefined, ...(id && { id }) })
+}
+
+/** Tool results as the model reads them. */
+export const toolResultFence = (lines: ReadonlyArray<string>) => `\`\`\`tool_result\n${lines.join("\n")}\n\`\`\``
+
+/**
+ * The first tool call in a fence's body: a JSON object (or an array of them,
+ * or one per line) with `name` and `arguments` (or `parameters`), the
+ * arguments possibly a JSON string; else, as the whole body, a Python-style
+ * call, `[name(key="v")]`, or `call:name{key:value}`.
+ */
+export function parseToolCall(body: string): ParsedToolCall | undefined {
+  const text = body.trim()
+  const candidates: Array<unknown> = []
+  try {
+    const value = JSON.parse(text) as unknown
+    candidates.push(...(Array.isArray(value) ? value : [value]))
+  } catch {
+    for (const line of text.split("\n")) {
+      try {
+        candidates.push(JSON.parse(line) as unknown)
+      } catch {
+        // Not JSON.
+      }
+    }
+  }
+  for (const call of candidates) {
+    if (!isObject(call) || typeof call.name !== "string" || !call.name) continue
+    let args: unknown = call.arguments ?? call.parameters ?? {}
+    if (typeof args === "string") {
+      try {
+        args = JSON.parse(args) as unknown
+      } catch {
+        // Left as the model wrote it.
+      }
+    }
+    return { name: call.name, arguments: args }
+  }
+  // `call:name{key:value,…}`
+  const colon = /^call:(\w+)\{([^}]*)\}$/.exec(text)
+  if (colon) return { name: colon[1], arguments: parseColonArguments(colon[2]) }
+  // Python style, `[name(key="value")]` or `name(key="value")`
+  return parsePythonCall(text)
+}
+
+/** `key:value,…` pairs, values read as numbers, booleans or null where they are. */
+function parseColonArguments(text: string): Record<string, unknown> {
+  const args: Record<string, unknown> = {}
+  for (const pair of text.split(",")) {
+    const at = pair.indexOf(":")
+    if (at <= 0) continue
+    const key = pair.slice(0, at).trim()
+    const raw = pair.slice(at + 1).trim()
+    const number = Number(raw)
+    args[key] =
+      raw === "true" ? true : raw === "false" ? false : raw === "null" ? null : raw !== "" && !Number.isNaN(number) ? number : raw
+  }
+  return args
+}
+
+/** The index of the bracket that closes the one at `open`, past quoted text, or -1. */
+function closing(text: string, open: number) {
+  const pairs: Record<string, string> = { "(": ")", "[": "]", "{": "}" }
+  const stack: Array<string> = []
+  let quote = ""
+  for (let i = open; i < text.length; i++) {
+    const c = text[i]
+    if (quote) {
+      if (c === "\\") i++
+      else if (c === quote) quote = ""
+    } else if (c === '"' || c === "'") quote = c
+    else if (pairs[c]) stack.push(pairs[c])
+    else if (c === stack.at(-1)) {
+      stack.pop()
+      if (stack.length === 0) return i
+    }
+  }
+  return -1
+}
+
+/** `text` split at its top-level commas (not inside quotes or brackets). */
+function splitTopLevel(text: string) {
+  const parts: Array<string> = []
+  let depth = 0
+  let quote = ""
+  let from = 0
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i]
+    if (quote) {
+      if (c === "\\") i++
+      else if (c === quote) quote = ""
+    } else if (c === '"' || c === "'") quote = c
+    else if ("([{".includes(c)) depth++
+    else if (")]}".includes(c)) depth--
+    else if (c === "," && depth === 0) {
+      parts.push(text.slice(from, i))
+      from = i + 1
+    }
+  }
+  parts.push(text.slice(from))
+  return parts.map((part) => part.trim()).filter(Boolean)
+}
+
+/** A Python literal (string, number, True/False/None, list, dict) as a value. */
+function pythonValue(raw: string): unknown {
+  const text = raw.trim()
+  if (text === "True") return true
+  if (text === "False") return false
+  if (text === "None") return null
+  if (/^(["']).*\1$/s.test(text)) return text.slice(1, -1).replace(/\\(["'\\])/g, "$1")
+  const json = text
+    .replace(/'((?:[^'\\]|\\.)*)'/g, (_, inner: string) => JSON.stringify(inner.replace(/\\'/g, "'")))
+    .replace(/\bTrue\b/g, "true")
+    .replace(/\bFalse\b/g, "false")
+    .replace(/\bNone\b/g, "null")
+  try {
+    return JSON.parse(json) as unknown
+  } catch {
+    return text
+  }
+}
+
+/** `text` as one Python-style call: `name(key=value, …)`, maybe in brackets. */
+function parsePythonCall(text: string): ParsedToolCall | undefined {
+  const match = /^(\[?\s*)(\w+)\(/.exec(text)
+  if (!match) return undefined
+  const open = match[0].length - 1
+  const close = closing(text, open)
+  if (close === -1 || text.slice(close + 1).trim() !== (match[1] ? "]" : "")) return undefined
+  const args: Record<string, unknown> = {}
+  for (const part of splitTopLevel(text.slice(open + 1, close))) {
+    const at = part.indexOf("=")
+    if (at <= 0) continue
+    args[part.slice(0, at).trim()] = pythonValue(part.slice(at + 1))
+  }
+  return { name: match[2], arguments: args }
+}
+
+/** Characters at the end of `text` that could start a fence. */
+function partialFenceStart(text: string) {
+  for (let size = Math.min(text.length, Math.max(...DELIMITERS.map((d) => d.start.length)) - 1); size > 0; size--) {
+    const end = text.slice(-size)
+    if (DELIMITERS.some((d) => d.start.startsWith(end))) return size
+  }
+  return 0
+}
+
+/**
+ * Reads a streamed reply: `push` each piece and get back the text that can
+ * be shown now; text inside a ```tool_call fence (or another call's
+ * delimiters: `<tool_call>`, `<|tool_call>`, `<|tool_call_start|>`, or a
+ * Python-style `[name(…)]`) is held back. The first fence that closes with
+ * a call in it ends the reply (stop generating then): `call` is the call,
+ * and `trailing` the text after it. A fence without a call, a call to a tool
+ * not in `names` (when given), and other code fences, are text. `end` gives
+ * the rest, an unclosed fence as text.
+ */
+export function toolCallReader(names?: ReadonlyArray<string>) {
+  let buffer = ""
+  // The delimiter of the call being read; a Python-style call is read whole.
+  let start: (Delimiter & { python?: boolean }) | undefined
+  let call: ParsedToolCall | undefined
+  // Text after the call, in the piece that closed it.
+  let trailing = ""
+
+  const read = (): string => {
+    let shown = ""
+    while (!call) {
+      if (!start) {
+        const python = PYTHON_CALL.exec(buffer)
+        const found = [
+          ...DELIMITERS.map((d) => ({ d, at: buffer.indexOf(d.start) })),
+          ...(python ? [{ d: { start: python[0], end: ")]", python: true }, at: python.index }] : [])
+        ]
+          .filter((f) => f.at !== -1)
+          .sort((a, b) => a.at - b.at)[0]
+        if (!found) {
+          const keep = partialFenceStart(buffer)
+          shown += buffer.slice(0, buffer.length - keep)
+          buffer = buffer.slice(buffer.length - keep)
+          return shown
+        }
+        shown += buffer.slice(0, found.at)
+        buffer = buffer.slice(found.at)
+        start = found.d
+      }
+      const close = buffer.indexOf(start.end, start.start.length)
+      if (close === -1) return shown
+      const fence = buffer.slice(0, close + start.end.length)
+      const parsed = parseToolCall(start.python ? fence : fence.slice(start.start.length, close))
+      call = parsed && (!names || names.includes(parsed.name)) ? parsed : undefined
+      buffer = buffer.slice(fence.length)
+      start = undefined
+      if (call) trailing = buffer
+      else shown += fence
+    }
+    return shown
+  }
+
+  return {
+    get call() {
+      return call
+    },
+    /** Text that came after the call: shown after it. */
+    get trailing() {
+      return trailing
+    },
+    push(piece: string): string {
+      buffer += piece
+      return read()
+    },
+    end(): string {
+      if (call) return ""
+      const rest = buffer
+      buffer = ""
+      return rest
+    }
+  }
+}

package/src/types.ts

@@ -0,0 +1,110 @@
+/**
+ * The parts of the Prompt API (https://github.com/webmachinelearning/prompt-api)
+ * this package uses. TypeScript's DOM library has no types for it yet.
+ * Shapes follow the spec and `@types/dom-chromium-ai`, kept here instead of
+ * depending on that package: it declares `LanguageModel` as a global (in
+ * every app that uses this package). Tools are left out: Chrome's tool use
+ * doesn't work on web pages, so the adapter calls tools by prompt
+ * (`tools.ts`). Names follow the spec: `contextUsage`,
+ * `contextWindow` and `contextoverflow` (web pages no longer have the old
+ * `inputUsage`, `inputQuota` and `quotaoverflow`).
+ */
+
+export type Availability =
+  "unavailable" | "downloadable" | "downloading" | "available"
+
+/** A download's progress, from 0 to 1. */
+export type DownloadProgressCallback = (progress: number) => void
+
+/** Sampling presets, for web pages (the raw `temperature` and `topK` are for extensions). */
+export type SamplingMode =
+  | "most-predictable"
+  | "predictable"
+  | "slightly-predictable"
+  | "balanced"
+  | "slightly-creative"
+  | "creative"
+  | "most-creative"
+
+export type LanguageModelMessageType = "text" | "image" | "audio"
+
+export type LanguageModelExpected = {
+  type: LanguageModelMessageType
+  languages?: Array<string>
+}
+
+/**
+ * A piece of a message: text, an image (`Blob`, `ImageBitmap`, canvas...)
+ * or audio (`Blob`, `AudioBuffer`...).
+ */
+export type LanguageModelContent = {
+  type: LanguageModelMessageType
+  value: unknown
+}
+
+export type LanguageModelMessage = {
+  role: "system" | "user" | "assistant"
+  content: string | Array<LanguageModelContent>
+}
+
+/** Options `availability()` takes, which `create()` takes too. */
+export type LanguageModelCoreOptions = {
+  expectedInputs?: Array<LanguageModelExpected>
+  expectedOutputs?: Array<LanguageModelExpected>
+  /** Web pages get it only with Chrome's Sampling Parameters origin trial. */
+  samplingMode?: SamplingMode
+  /** Extensions only; web pages ignore them. Chrome refuses them together with `samplingMode`. */
+  temperature?: number
+  topK?: number
+}
+
+export type LanguageModelCreateOptions = LanguageModelCoreOptions & {
+  initialPrompts?: Array<LanguageModelMessage>
+  /** Aborting it destroys the session, during `create()` or after. */
+  signal?: AbortSignal
+  monitor?: (monitor: EventTarget) => void
+}
+
+export type LanguageModelPromptOptions = {
+  signal?: AbortSignal
+  /** A JSON Schema (or RegExp) the reply must match. */
+  responseConstraint?: object
+  omitResponseConstraintInput?: boolean
+}
+
+export type LanguageModelInput = string | Array<LanguageModelMessage>
+
+export interface LanguageModelSession extends EventTarget {
+  /** Tokens the session holds. */
+  readonly contextUsage: number
+  /** Tokens it can hold. */
+  readonly contextWindow: number
+  /** The preset the session samples with; null when made with raw parameters. */
+  readonly samplingMode?: SamplingMode | null
+  prompt(
+    input: LanguageModelInput,
+    options?: LanguageModelPromptOptions
+  ): Promise<string>
+  /** The reply's text, in pieces as it's written. */
+  promptStreaming(
+    input: LanguageModelInput,
+    options?: LanguageModelPromptOptions
+  ): ReadableStream<string> & AsyncIterable<string>
+  measureContextUsage(
+    input: LanguageModelInput,
+    options?: LanguageModelPromptOptions
+  ): Promise<number>
+  destroy(): void
+}
+
+export type LanguageModelStatic = {
+  availability(options?: LanguageModelCoreOptions): Promise<Availability>
+  create(options?: LanguageModelCreateOptions): Promise<LanguageModelSession>
+}
+
+/** The `downloadprogress` event: `loaded` goes from 0 to 1. */
+export type DownloadProgressEvent = Event & { loaded: number; total?: number }
+
+/** The page's `LanguageModel`, or undefined where the browser has none. */
+export const languageModel = () =>
+  (globalThis as { LanguageModel?: LanguageModelStatic }).LanguageModel