@tanstack-ai-browser/webgllm 0.0.0-stage → 0.2.1

package/src/adapter.ts

@@ -0,0 +1,291 @@
+/**
+ * A TanStack AI text adapter for webgllm: LFM3, LFM2.5 and Qwen3.5 on
+ * WebGL 2 in a Web Worker, for browsers without WebGPU, reading images
+ * where the model has a vision encoder. webgllm answers
+ * OpenAI's Chat Completions API in the page, so this is TanStack's Chat
+ * Completions adapter with the page's `WebGLLM` instance as its client (or
+ * the one for the adapter's own `worker`):
+ * messages, tools, structured output and the stream (text, thinking, tool
+ * calls) are TanStack's. This file adds what's webgllm's own: loading the
+ * model before a call, and its reasoning levels and thinking budget.
+ */
+import type { AdapterYieldChunk, ModelReasoning, TextOptions, TokenUsage } from "@tanstack/ai"
+import { resolveReasoning } from "@tanstack/ai/adapter-internals"
+import type { StructuredOutputOptions, StructuredOutputResult } from "@tanstack/ai/adapters"
+import { OpenAIBaseChatCompletionsTextAdapter } from "@tanstack/openai-base"
+import type { OpenAIClientLike } from "@tanstack/openai-base"
+import { WebGLLM } from "webgllm"
+import type { ChatCompletionCreateParamsBase, LoadProgress } from "webgllm"
+
+import { modelMeta, WEBGLLM_MODEL_META } from "./catalog.js"
+import type { WebGllmChatModel, WebGllmModelReasoningByName } from "./catalog.js"
+
+/**
+ * Where a model stands in this browser, with the Prompt API's values
+ * (`LanguageModel.availability()`).
+ */
+export type Availability = "unavailable" | "downloadable" | "downloading" | "available"
+
+/** A download's progress, from 0 to 1. */
+export type DownloadProgressCallback = (progress: number) => void
+
+/** A `WebGLLM` (running in `worker`, if given), and the models downloading in it, from its events. */
+function createEngine(worker?: Worker) {
+  const webgllm = new WebGLLM(worker && { worker })
+  const downloading = new Set<string>()
+  webgllm.addEventListener("progress", ({ model, phase, cached }) => {
+    if (phase === "download" && !cached) downloading.add(model)
+  })
+  for (const type of ["load", "error", "unload"] as const) {
+    webgllm.addEventListener(type, ({ model }) => downloading.delete(model))
+  }
+  return { webgllm, downloading }
+}
+
+type Engine = ReturnType<typeof createEngine>
+
+/** The page's engine, shared by every adapter without a worker of its own. */
+const pageEngine = createEngine()
+
+/** The page's `WebGLLM`. Exported for tests. */
+export const webgllm = pageEngine.webgllm
+
+/** The engines in the callers' own workers: one a worker, as each worker's handler holds one model. */
+const workerEngines = new WeakMap<Worker, Engine>()
+
+/** An adapter's engine: its own worker's (shared by every adapter given that worker), else the page's. */
+function engineFor(worker?: Worker): Engine {
+  if (!worker) return pageEngine
+  let engine = workerEngines.get(worker)
+  if (!engine) workerEngines.set(worker, (engine = createEngine(worker)))
+  return engine
+}
+
+let supported: boolean | undefined
+/** Whether the engine runs here, checked once: webgllm's check makes a WebGL context. */
+const engineRuns = () => (supported ??= WebGLLM.isSupported())
+
+/** The download's share of webgllm's load progress (downloading is its first 90%). */
+const downloadShare = ({ progress, loadedBytes, totalBytes }: LoadProgress) =>
+  totalBytes ? Math.min((loadedBytes ?? 0) / totalBytes, 1) : Math.min(progress / 0.9, 1)
+
+/**
+ * Per-call `modelOptions`: webgllm's own request fields (OpenAI's names, and
+ * its `top_k`, `min_p`, `repetition_penalty` and `repair_tool_calls`), sent
+ * as given. The fields the adapter writes from `chat()`'s own options
+ * (messages, tools, the output schema, streaming, reasoning) are left out.
+ */
+export type WebGllmTextModelOptions = Omit<
+  ChatCompletionCreateParamsBase,
+  | "model"
+  | "messages"
+  | "stream"
+  | "stream_options"
+  | "tools"
+  | "tool_choice"
+  | "response_format"
+  | "reasoning_effort"
+  | "reasoning"
+>
+
+/** Options for `webgllmText`. */
+export type WebGllmConfig = {
+  /**
+   * Most tokens a chat may hold, prompt and reply together: the model's
+   * whole context length by default, never more. A smaller limit takes less
+   * memory and refuses longer chats sooner. Changing it loads the model again.
+   */
+  contextLength?: number
+  /**
+   * A Web Worker of your own to run the model in, in place of the ones
+   * webgllm starts (webgllm's `worker` option): a module whose `onmessage`
+   * goes to webgllm's `WebGLLMWorkerHandler` (exported here too). It holds
+   * one model, so adapters given the same worker share it and loading
+   * another model replaces the one there; `destroy()` frees the model and
+   * leaves the worker running.
+   */
+  worker?: Worker
+  /**
+   * The model's download progress, 0 to 1, when a call (`chat()`, say)
+   * starts its download; then 1 once it's ready. To load it ahead of time
+   * with progress, see `create`.
+   */
+  onDownloadProgress?: DownloadProgressCallback
+}
+
+/** A model's reasoning levels: a listed model's, none for a listed one that doesn't reason, else the switch. */
+type ResolveReasoning<TModel extends string> = TModel extends keyof WebGllmModelReasoningByName
+  ? WebGllmModelReasoningByName[TModel]
+  : TModel extends WebGllmChatModel
+    ? never
+    : { levels: "off" | "high"; budget: false }
+
+/** A model the catalog lists, any Hugging Face repo webgllm can resolve, or the URL of a `.gguf` file or `.onnx` graph. */
+export type WebGllmModel = WebGllmChatModel | (string & {})
+
+/** The switch for a model the catalog doesn't list: webgllm's `reasoning_effort`, a hint it ignores where it can't apply. */
+const UNLISTED_REASONING = { levels: { off: "none", high: "high" }, budget: false } as const
+
+const listed = (model: string): model is WebGllmChatModel => Object.prototype.hasOwnProperty.call(WEBGLLM_MODEL_META, model)
+
+type MetadataByModality = { text: unknown; image: unknown; audio: unknown; video: unknown; document: unknown }
+
+/** A Chat Completions request, as the base adapter writes it. */
+type CreateParams = Parameters<OpenAIClientLike["chat"]["completions"]["create"]>[0]
+
+const signalOf = (options: TextOptions) =>
+  options.abortController?.signal ?? (options.request as RequestInit | undefined)?.signal ?? undefined
+
+export class WebGllmTextAdapter<TModel extends WebGllmModel> extends OpenAIBaseChatCompletionsTextAdapter<
+  TModel,
+  WebGllmTextModelOptions,
+  ReadonlyArray<"text" | "image">,
+  MetadataByModality,
+  ReadonlyArray<string>,
+  ResolveReasoning<TModel>
+> {
+  override readonly name = "webgllm"
+  override readonly api = "webgllm"
+  /**
+   * What the model reads, from webgllm's catalog: images too for a model
+   * with a vision encoder (Qwen3.5's ONNX build). Not known for a model the
+   * catalog doesn't list (webgllm's `models.retrieve()` says, once loaded).
+   */
+  override readonly inputModalities: ReadonlyArray<"text" | "image"> | undefined
+
+  private readonly contextLength: number | undefined
+  private readonly onDownloadProgress: DownloadProgressCallback | undefined
+  /** The `WebGLLM` the model loads in: the page's, or the adapter's own worker's. */
+  private readonly engine: Engine
+
+  constructor(config: WebGllmConfig, model: TModel) {
+    const engine = engineFor(config.worker)
+    // Chat Completions (`chat.completions.create`) is all the adapter calls.
+    super(model, "webgllm", engine.webgllm as unknown as OpenAIClientLike, { strictFallbackWarning: false })
+    this.engine = engine
+    this.contextLength = config.contextLength
+    this.onDownloadProgress = config.onDownloadProgress
+    this.inputModalities = listed(model) ? modelMeta(model).supports.input : undefined
+  }
+
+  /**
+   * Where the model stands in this browser, with the Prompt API's values:
+   * "unavailable" where the engine can't run (WebGL 2 with float render
+   * targets, in a worker), "downloading" while this page downloads it,
+   * "available" when it's loaded or its files are in webgllm's storage,
+   * else "downloadable". It reads storage only.
+   */
+  async availability(): Promise<Availability> {
+    const { webgllm, downloading } = this.engine
+    if (!engineRuns()) return "unavailable"
+    if (downloading.has(this.model)) return "downloading"
+    const stored = await webgllm.models.downloaded(this.model).catch(() => false)
+    return stored ? "available" : "downloadable"
+  }
+
+  /**
+   * Loads the model for this adapter's `contextLength` (downloading it the
+   * first time), with the download's progress, 0 to 1, then 1 once it's
+   * ready. Resolves to this adapter; rejects if it can't load (fine to leave
+   * unawaited). `chat()` doesn't need it: its first call loads the model.
+   */
+  create(options: { onDownloadProgress?: DownloadProgressCallback; signal?: AbortSignal } = {}): Promise<this> {
+    const ready = this.load(options.signal, options.onDownloadProgress).then(() => this)
+    ready.catch(() => undefined)
+    return ready
+  }
+
+  /** Unloads the model, freeing its GPU memory. Its files stay. Never rejects. */
+  destroy(): Promise<void> {
+    return this.engine.webgllm.unloadModel(this.model).catch(() => undefined)
+  }
+
+  /**
+   * Loads the model for this adapter's context length; webgllm returns at
+   * once when it's loaded for it, and shares a load between its callers.
+   */
+  private async load(signal?: AbortSignal | null, onDownloadProgress?: DownloadProgressCallback) {
+    const report = (progress: number) => {
+      this.onDownloadProgress?.(progress)
+      onDownloadProgress?.(progress)
+    }
+    await this.engine.webgllm.loadModel(this.model, {
+      ...(this.contextLength !== undefined && { contextLength: this.contextLength }),
+      ...(signal && { signal }),
+      onProgress: (progress) => {
+        if (progress.phase === "download" && !progress.cached) report(downloadShare(progress))
+      }
+    })
+    report(1)
+  }
+
+  override async *chatStream(options: TextOptions<WebGllmTextModelOptions>): AsyncIterable<AdapterYieldChunk> {
+    await this.load(signalOf(options))
+    yield* super.chatStream(options)
+  }
+
+  override async *structuredOutputStream(options: StructuredOutputOptions<WebGllmTextModelOptions>): AsyncIterable<AdapterYieldChunk> {
+    await this.load(signalOf(options.chatOptions))
+    yield* super.structuredOutputStream(options)
+  }
+
+  override async structuredOutput(options: StructuredOutputOptions<WebGllmTextModelOptions>): Promise<StructuredOutputResult<unknown>> {
+    await this.load(signalOf(options.chatOptions))
+    return super.structuredOutput(options)
+  }
+
+  /** The request, with `modelOptions` as given, the thinking budget and the prompt cache. */
+  /**
+   * The engine's usage, as TanStack converts it, but with a cached count of 0
+   * kept, which TanStack's conversion leaves out: 0 means the whole prompt was
+   * read, where no count means the engine didn't say.
+   */
+  protected override chatCompletionsTokenUsage(
+    usage: { prompt_tokens_details?: { cached_tokens?: number } | null } | null | undefined,
+    source?: unknown
+  ): TokenUsage | undefined {
+    const result = super.chatCompletionsTokenUsage(usage as never, source)
+    const cachedTokens = usage?.prompt_tokens_details?.cached_tokens
+    if (!result || cachedTokens !== 0) return result
+    return { ...result, promptTokensDetails: { ...result.promptTokensDetails, cachedTokens } }
+  }
+
+  protected override mapOptionsToRequest(options: TextOptions): CreateParams & { stream: true } {
+    const request = super.mapOptionsToRequest(options)
+    const resolved = resolveReasoning(options.reasoning, this.modelReasoning(this.model))
+    const budget = resolved?.value === "high" ? resolved.budgetTokens : undefined
+    return Object.assign(request, {
+      ...(budget !== undefined && { reasoning: { max_tokens: budget } }),
+      ...(options.promptCache?.retention === "none" && { cache_prompt: false })
+    })
+  }
+
+  protected override modelReasoning(model: string) {
+    return (listed(model) ? modelMeta(model).reasoning : UNLISTED_REASONING) as ModelReasoning | undefined
+  }
+
+  /** webgllm streams thinking as `reasoning_content`. */
+  protected override extractReasoning(chunk: unknown) {
+    const text = (chunk as { choices?: Array<{ delta?: { reasoning_content?: string } }> }).choices?.[0]?.delta
+      ?.reasoning_content
+    return text ? { text } : undefined
+  }
+
+  /** Schemas as given: webgllm constrains to any JSON Schema, without OpenAI's strict-mode rewrite. */
+  protected override makeStructuredOutputCompatible(schema: Record<string, any>) {
+    return schema
+  }
+}
+
+/**
+ * A TanStack AI text adapter for a webgllm model on WebGL 2, for browsers
+ * without WebGPU (Firefox on Android, for one).
+ *
+ * @example
+ * ```ts
+ * chat({ adapter: webgllmText("LiquidAI/LFM3-1.7B-GGUF"), messages, threadId })
+ * ```
+ */
+export function webgllmText<TModel extends WebGllmModel>(model: TModel, config?: WebGllmConfig): WebGllmTextAdapter<TModel> {
+  return new WebGllmTextAdapter(config ?? {}, model)
+}

package/src/catalog.ts

@@ -0,0 +1,35 @@
+/**
+ * The models webgllm runs: webgllm's own catalog, re-exported under this
+ * adapter's names, with their reasoning levels in TanStack AI's shape (for
+ * `chat({ reasoning })` and `supportedReasoningLevels()`).
+ */
+import type { ModelReasoning } from "@tanstack/ai"
+import type { ModelReasoningCapability } from "@tanstack/ai/adapter-internals"
+import { WEBGL_MODEL_META, WEBGL_TEXT_MODELS } from "webgllm"
+import type { WebGlModelMeta, WebGlModelReasoning, WebGlTextModel } from "webgllm"
+
+// webgllm's catalog as it is: the models it runs, and each one's entry by name.
+export { WEBGL_TEXT_MODELS as WEBGLLM_CHAT_MODELS, WEBGL_MODEL_META as WEBGLLM_MODEL_META } from "webgllm"
+export type { WebGlTextModel as WebGllmChatModel, WebGlModelMeta as WebGllmModelMeta } from "webgllm"
+
+type WebGllmChatModel = WebGlTextModel
+
+/**
+ * The reasoning levels of each model that thinks, exactly as its catalog
+ * entry gives them: LFM3 and Qwen3.5 switch between `off` and `high`, the
+ * LFM2.5 Thinking builds always think (`high` only). Models that don't think
+ * aren't in it.
+ */
+export type WebGllmModelReasoningByName = {
+  [K in WebGllmChatModel as WebGlModelReasoning<K> extends undefined ? never : K]: ModelReasoningCapability<
+    NonNullable<WebGlModelReasoning<K>>
+  >
+}
+
+/** Reasoning data of each model (`false`: it doesn't think), for `supportedReasoningLevels()`. */
+export const WEBGLLM_MODEL_REASONING = Object.fromEntries(
+  WEBGL_TEXT_MODELS.map((model) => [model, WEBGL_MODEL_META[model].reasoning ?? false])
+) as Readonly<Record<WebGllmChatModel, ModelReasoning>>
+
+/** A model's catalog entry. */
+export const modelMeta = (model: WebGllmChatModel): WebGlModelMeta => WEBGL_MODEL_META[model]

package/src/fake-webgllm.test.ts

@@ -0,0 +1,236 @@
+/**
+ * A stand-in for the shared WebGLLM instance's methods, so the adapter's
+ * tests run without workers or models: loads resolve at once (after the
+ * scripted download progress), and each completion streams the chunks the
+ * test scripts. (No tests of its own.)
+ */
+import type {
+  ChatCompletionChunk,
+  ChatCompletionChunkDelta,
+  ChatCompletionCreateParamsStreaming,
+  CompletionTimings,
+  FinishReason,
+  LoadModelOptions,
+  LoadProgress,
+  RequestOptions,
+  WebGLLMEventMap
+} from "webgllm"
+import { resolveDebugOption } from "@tanstack/ai/adapter-internals"
+import type { TextOptions } from "@tanstack/ai"
+
+import { webgllm } from "./adapter.js"
+import type { WebGllmTextModelOptions } from "./adapter.js"
+
+export const MODEL = "LiquidAI/LFM3-1.7B-GGUF"
+
+/** What a scripted completion streams: chunks, an Error to throw there, or a pause. */
+export type Step = ChatCompletionChunk | Error | { wait: Promise<void> }
+
+export const fake = {
+  requests: [] as Array<{ body: ChatCompletionCreateParamsStreaming; options: RequestOptions }>,
+  loads: [] as Array<{ model: string; options: LoadModelOptions }>,
+  unloads: [] as Array<string | undefined>,
+  /** Models the fake holds loaded, with the context each was loaded for. */
+  loaded: new Map<string, number | undefined>(),
+  /** Models whose files the fake's storage holds (models.downloaded). */
+  stored: new Set<string>(),
+  /** Download progress each load reports before it finishes. */
+  progress: [] as Array<LoadProgress>,
+  /** Rejects the next loads with it. */
+  loadError: undefined as Error | undefined,
+  /** Holds loads until it resolves. */
+  loadGate: undefined as Promise<void> | undefined,
+  /** The steps of each completion, from its request. */
+  script: (() => [chunk({ role: "assistant", content: "Hello" }), chunk({}, "stop"), usageChunk()]) as (
+    body: ChatCompletionCreateParamsStreaming
+  ) => Array<Step>,
+  reset() {
+    this.requests = []
+    this.loads = []
+    this.unloads = []
+    this.loaded.clear()
+    this.stored.clear()
+    this.progress = []
+    this.loadError = undefined
+    this.loadGate = undefined
+    this.script = () => [chunk({ role: "assistant", content: "Hello" }), chunk({}, "stop"), usageChunk()]
+  }
+}
+
+export function chunk(delta: ChatCompletionChunkDelta, finish: FinishReason | null = null): ChatCompletionChunk {
+  return {
+    id: "chatcmpl-test",
+    object: "chat.completion.chunk",
+    created: 0,
+    model: MODEL,
+    choices: [{ index: 0, delta, finish_reason: finish, logprobs: null }]
+  }
+}
+
+export const TIMINGS: CompletionTimings = {
+  first_token_ms: 12,
+  prompt_ms: 10,
+  decode_ms: 40,
+  prompt_tokens_per_second: 900,
+  decode_tokens_per_second: 25
+}
+
+export function usageChunk(
+  usage: { prompt?: number; completion?: number; cached?: number; reasoning?: number } = {}
+): ChatCompletionChunk {
+  const prompt = usage.prompt ?? 9
+  const completion = usage.completion ?? 2
+  return {
+    id: "chatcmpl-test",
+    object: "chat.completion.chunk",
+    created: 0,
+    model: MODEL,
+    choices: [],
+    usage: {
+      prompt_tokens: prompt,
+      completion_tokens: completion,
+      total_tokens: prompt + completion,
+      prompt_tokens_details: { cached_tokens: usage.cached ?? 0 },
+      completion_tokens_details: { reasoning_tokens: usage.reasoning ?? 0 }
+    },
+    timings: TIMINGS
+  }
+}
+
+const tick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
+const abortError = () => new DOMException("The operation was aborted.", "AbortError")
+
+function stream(steps: Array<Step>, signal: AbortSignal | undefined): AsyncIterable<ChatCompletionChunk> {
+  let i = 0
+  let done = false
+  const iterator: AsyncIterator<ChatCompletionChunk> = {
+    async next() {
+      for (;;) {
+        await tick()
+        if (signal?.aborted) throw abortError()
+        if (done || i >= steps.length) return { value: undefined, done: true }
+        const step = steps[i++]!
+        if (step instanceof Error) throw step
+        if ("wait" in step) {
+          await step.wait
+          continue
+        }
+        return { value: step, done: false }
+      }
+    },
+    async return() {
+      done = true
+      return { value: undefined, done: true }
+    }
+  }
+  return { [Symbol.asyncIterator]: () => iterator }
+}
+
+/** Dispatches a lifecycle event on the real instance, as webgllm itself does. */
+export function emit<K extends keyof WebGLLMEventMap>(type: K, event: WebGLLMEventMap[K]) {
+  ;(webgllm as unknown as { dispatch(type: K, event: WebGLLMEventMap[K]): void }).dispatch(type, event)
+}
+
+const abortable = (promise: Promise<void>, signal?: AbortSignal) =>
+  signal
+    ? Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          if (signal.aborted) reject(signal.reason)
+          signal.addEventListener("abort", () => reject(signal.reason), { once: true })
+        })
+      ])
+    : promise
+
+// Like webgllm's loadModel: at once when loaded for that context; otherwise
+// the scripted download progress (with webgllm's events), then "load".
+webgllm.loadModel = async (model, options = {}) => {
+  options.signal?.throwIfAborted()
+  fake.loads.push({ model, options })
+  if (fake.loaded.has(model) && fake.loaded.get(model) === options.contextLength) return
+  for (const progress of fake.progress) {
+    emit("progress", progress)
+    options.onProgress?.(progress)
+  }
+  await abortable(fake.loadGate ?? Promise.resolve(), options.signal)
+  if (fake.loadError) {
+    emit("error", { model, error: fake.loadError })
+    throw fake.loadError
+  }
+  fake.loaded.set(model, options.contextLength)
+  emit("load", { model, contextLength: options.contextLength ?? 32_768 })
+}
+webgllm.unloadModel = async (model) => {
+  fake.unloads.push(model)
+  for (const name of model === undefined ? [...fake.loaded.keys()] : [model]) {
+    if (fake.loaded.delete(name)) emit("unload", { model: name, reason: "unloaded" })
+  }
+}
+webgllm.models.downloaded = async (model) => fake.loaded.has(model) || fake.stored.has(model)
+webgllm.chat.completions.create = (async (body: ChatCompletionCreateParamsStreaming, options: RequestOptions = {}) => {
+  fake.requests.push({ body, options })
+  options.signal?.throwIfAborted()
+  if (body.stream !== true) return completion(body, fake.script(body))
+  return stream(fake.script(body), options.signal)
+}) as typeof webgllm.chat.completions.create
+
+/** A request without `stream`: the scripted chunks as one completion, as webgllm answers it. */
+async function completion(body: { model: string }, steps: Array<Step>) {
+  let content = ""
+  let reasoning = ""
+  let finish: FinishReason | null = null
+  let usage: ChatCompletionChunk["usage"]
+  for (const step of steps) {
+    if (step instanceof Error) throw step
+    if ("wait" in step) {
+      await step.wait
+      continue
+    }
+    const choice = step.choices[0]
+    content += choice?.delta.content ?? ""
+    reasoning += choice?.delta.reasoning_content ?? ""
+    finish = choice?.finish_reason ?? finish
+    usage = step.usage ?? usage
+  }
+  return {
+    id: "chatcmpl-fake",
+    object: "chat.completion",
+    created: 0,
+    model: body.model,
+    choices: [
+      {
+        index: 0,
+        message: { role: "assistant", content, ...(reasoning && { reasoning_content: reasoning }) },
+        finish_reason: finish ?? "stop"
+      }
+    ],
+    ...(usage && { usage })
+  }
+}
+
+/** A chatStream call's options. */
+export function textOptions(
+  extra: Partial<TextOptions<WebGllmTextModelOptions>> = {}
+): TextOptions<WebGllmTextModelOptions> {
+  return {
+    logger: resolveDebugOption(false),
+    threadId: "webgllm-test",
+    model: MODEL,
+    messages: [{ role: "user", content: "hi" }],
+    ...extra
+  }
+}
+
+/** Every event a stream yields. */
+export async function collect<T>(stream: AsyncIterable<T>): Promise<Array<T>> {
+  const out: Array<T> = []
+  for await (const event of stream) out.push(event)
+  return out
+}
+
+/** The last request's body. */
+export const lastBody = () => {
+  const request = fake.requests.at(-1)
+  if (!request) throw new Error("No request was sent.")
+  return request.body
+}

package/src/index.ts

@@ -0,0 +1,11 @@
+/**
+ * TanStack AI adapter for webgllm: LFM3, LFM2.5 and Qwen3.5 in the browser
+ * on WebGL 2, for browsers without WebGPU (Firefox on Android, for one).
+ * The model catalog (model-meta.ts) is exported here too.
+ */
+export { webgllmText, WebGllmTextAdapter } from "./adapter.js"
+export type { Availability, DownloadProgressCallback, WebGllmConfig, WebGllmModel, WebGllmTextModelOptions } from "./adapter.js"
+// webgllm's own worker handler, for a worker of your own (`worker` in the adapter's config).
+export { WebGLLMWorkerHandler } from "webgllm"
+export { WEBGLLM_CHAT_MODELS, WEBGLLM_MODEL_META, WEBGLLM_MODEL_REASONING } from "./catalog.js"
+export type { WebGllmChatModel, WebGllmModelMeta, WebGllmModelReasoningByName } from "./catalog.js"

package/src/unavailable.test.ts

@@ -0,0 +1,10 @@
+/** Where the engine can't run (Node has no WebGL 2), every model is "unavailable". */
+import assert from "node:assert/strict"
+import { test } from "node:test"
+
+import { webgllmText } from "./adapter.js"
+import { MODEL } from "./fake-webgllm.test.js"
+
+test("availability is unavailable where the engine can't run", async () => {
+  assert.equal(await webgllmText(MODEL).availability(), "unavailable")
+})