@aparte/provider-transformers 0.2.0-alpha.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 aparté
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,36 @@
+# @aparte/provider-transformers
+
+Run LLMs **100% in the browser** via [Transformers.js](https://huggingface.co/docs/transformers.js)
+(WebGPU, with a WASM fallback) — no API, no key, no server. Inference runs off the main thread in
+a **Web Worker**, streaming tokens into aparté.
+
+```bash
+npm install @aparte/provider-transformers @huggingface/transformers
+```
+
+`@huggingface/transformers` is a **peer dependency** — you bring the version you want (it's heavy and
+ships its own onnxruntime). `@aparte/core` is a **peer dependency**.
+
+```ts
+import { AparteConfig, DirectTransport } from '@aparte/core';
+import { TransformersProvider, registerModel } from '@aparte/provider-transformers';
+
+registerModel({
+  id: 'onnx-community/Qwen2.5-0.5B-Instruct',
+  name: 'Qwen2.5 0.5B',
+  task: 'text-generation',
+  capabilities: ['streaming'],
+  dtype: 'q4',
+});
+AparteConfig.registerAIProvider(TransformersProvider);
+AparteConfig.setTransport(new DirectTransport({ byok: true }));
+```
+
+The provider owns its I/O (it runs inference locally), so `DirectTransport` just delegates to it.
+Model weights download once and persist in the Cache API; `prepareModel` reports progress, and
+`listCachedModels` / `deleteCachedModel` manage the on-disk cache.
+
+> **Scope (v1):** generic text-generation streaming. Tool-calling for local models is
+> model-specific and out of scope for now. Part of the
+> [aparté](https://github.com/apartejs/aparte) monorepo. ESM-only.
+> See the **Providers** guide in the docs for the full usage.

package/dist/assets/worker-Bk-8pt3W.js

@@ -0,0 +1,70 @@
+import { env, InterruptableStoppingCriteria, TextStreamer, pipeline } from "@huggingface/transformers";
+env.allowLocalModels = false;
+env.useBrowserCache = true;
+const ctx = self;
+function post(message) {
+  ctx.postMessage(message);
+}
+let _current = null;
+const _activeStops = /* @__PURE__ */ new Map();
+async function ensurePipeline(modelId, dtype, device, id) {
+  if (_current?.modelId === modelId) return _current.pipe;
+  const opts = {
+    progress_callback: (p) => {
+      if (!id) return;
+      if (p.status === "progress") {
+        post({ type: "progress", id, status: "downloading", file: p.file, progress: Math.round(p.progress ?? 0) });
+      } else if (p.status === "done") {
+        post({ type: "progress", id, status: "loading", file: p.file });
+      }
+    }
+  };
+  if (dtype) opts["dtype"] = dtype;
+  if (device && device !== "auto") opts["device"] = device;
+  const pipe = await pipeline("text-generation", modelId, opts);
+  _current = { modelId, pipe };
+  post({ type: "pipeline-ready", modelId });
+  return pipe;
+}
+async function handlePrepare(msg) {
+  try {
+    await ensurePipeline(msg.modelId, msg.dtype, msg.device, msg.id);
+    post({ type: "progress", id: msg.id, status: "ready" });
+  } catch (err) {
+    post({ type: "prepare-error", id: msg.id, message: err?.message ?? "Failed to load model" });
+  }
+}
+async function handleGenerate(msg) {
+  const stoppingCriteria = new InterruptableStoppingCriteria();
+  _activeStops.set(msg.id, stoppingCriteria);
+  try {
+    const pipe = await ensurePipeline(msg.modelId, msg.dtype, msg.device, msg.id);
+    const streamer = new TextStreamer(pipe.tokenizer, {
+      skip_prompt: true,
+      skip_special_tokens: true,
+      callback_function: (text) => {
+        if (text) post({ type: "gen-chunk", id: msg.id, chunkType: "text", delta: text });
+      }
+    });
+    const temperature = msg.options.temperature ?? 0;
+    await pipe(msg.messages, {
+      max_new_tokens: msg.options.maxTokens ?? 512,
+      do_sample: temperature > 0,
+      temperature: temperature > 0 ? temperature : void 0,
+      streamer,
+      stopping_criteria: stoppingCriteria
+    });
+    post({ type: "gen-done", id: msg.id });
+  } catch (err) {
+    post({ type: "gen-error", id: msg.id, message: err?.message ?? "Generation failed" });
+  } finally {
+    _activeStops.delete(msg.id);
+  }
+}
+ctx.addEventListener("message", (event) => {
+  const msg = event.data;
+  if (msg.type === "prepare") void handlePrepare(msg);
+  else if (msg.type === "generate") void handleGenerate(msg);
+  else if (msg.type === "cancel") _activeStops.get(msg.id)?.interrupt();
+});
+//# sourceMappingURL=worker-Bk-8pt3W.js.map

package/dist/assets/worker-Bk-8pt3W.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-Bk-8pt3W.js","sources":["../src/worker.ts"],"sourcesContent":["/**\n * Generic Transformers.js inference worker.\n *\n * Runs entirely off the main thread. It holds ONE text-generation pipeline at a\n * time and speaks a tiny postMessage protocol with the provider on the main\n * thread (see `index.ts`):\n *\n *   main → worker : { type: 'prepare',  id, modelId, dtype?, device? }\n *                   { type: 'generate', id, modelId, messages, options, dtype?, device? }\n *   worker → main : { type: 'progress', id, status, file?, progress? }\n *                   { type: 'prepare-error', id, message }\n *                   { type: 'pipeline-ready', modelId }\n *                   { type: 'gen-chunk', id, chunkType: 'text', delta }\n *                   { type: 'gen-done', id }\n *                   { type: 'gen-error', id, message }\n *\n * Deliberately generic: no vision, no low-level ORT session management, no\n * model-family specifics — just the high-level `pipeline()` + `TextStreamer`.\n */\n\nimport { pipeline, TextStreamer, InterruptableStoppingCriteria, env, type TextGenerationPipeline } from '@huggingface/transformers';\n\n// Fetch weights from the Hugging Face hub (not local paths) and cache them in the\n// browser Cache API — this is what `listCachedModels()` scans on the main thread.\nenv.allowLocalModels = false;\nenv.useBrowserCache = true;\n\n// DOM's `Worker` interface types `postMessage` + typed `addEventListener('message')`,\n// which is enough for the worker scope — avoids pulling the WebWorker lib (it clashes\n// with DOM's global `postMessage`).\nconst ctx = self as unknown as Worker;\n\ntype Dtype = string | Record<string, string>;\ntype Device = 'webgpu' | 'wasm' | 'auto';\ninterface GenOptions { maxTokens?: number; temperature?: number; seed?: number }\ntype SimpleMessage = { role: 'user' | 'assistant' | 'system'; content: string };\n\ntype InMessage =\n    | { type: 'prepare'; id: string; modelId: string; dtype?: Dtype; device?: Device }\n    | { type: 'generate'; id: string; modelId: string; messages: SimpleMessage[]; options: GenOptions; dtype?: Dtype; device?: Device }\n    | { type: 'cancel'; id: string };\n\nfunction post(message: unknown): void {\n    ctx.postMessage(message);\n}\n\nlet _current: { modelId: string; pipe: TextGenerationPipeline } | null = null;\n// Per-generate interrupts, so a consumer's stream-cancel actually STOPS the model\n// (not just detaches the reader) — otherwise generation runs to max_new_tokens\n// off-thread, wasting exactly the CPU/GPU/battery this provider exists to save.\nconst _activeStops = new Map<string, InterruptableStoppingCriteria>();\n\n/**\n * Ensure the pipeline for `modelId` is loaded, reusing the current one when it\n * matches. On a fresh load it forwards download progress (when `id` is given) and\n * announces `pipeline-ready`.\n */\nasync function ensurePipeline(modelId: string, dtype: Dtype | undefined, device: Device | undefined, id?: string): Promise<TextGenerationPipeline> {\n    if (_current?.modelId === modelId) return _current.pipe;\n\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const opts: Record<string, any> = {\n        progress_callback: (p: { status?: string; file?: string; progress?: number }) => {\n            if (!id) return;\n            if (p.status === 'progress') {\n                post({ type: 'progress', id, status: 'downloading', file: p.file, progress: Math.round(p.progress ?? 0) });\n            } else if (p.status === 'done') {\n                post({ type: 'progress', id, status: 'loading', file: p.file });\n            }\n        },\n    };\n    if (dtype) opts['dtype'] = dtype;\n    if (device && device !== 'auto') opts['device'] = device;\n\n    const pipe = await pipeline('text-generation', modelId, opts) as TextGenerationPipeline;\n    _current = { modelId, pipe };\n    post({ type: 'pipeline-ready', modelId });\n    return pipe;\n}\n\nasync function handlePrepare(msg: Extract<InMessage, { type: 'prepare' }>): Promise<void> {\n    try {\n        await ensurePipeline(msg.modelId, msg.dtype, msg.device, msg.id);\n        post({ type: 'progress', id: msg.id, status: 'ready' });\n    } catch (err) {\n        post({ type: 'prepare-error', id: msg.id, message: (err as Error)?.message ?? 'Failed to load model' });\n    }\n}\n\nasync function handleGenerate(msg: Extract<InMessage, { type: 'generate' }>): Promise<void> {\n    const stoppingCriteria = new InterruptableStoppingCriteria();\n    _activeStops.set(msg.id, stoppingCriteria);\n    try {\n        const pipe = await ensurePipeline(msg.modelId, msg.dtype, msg.device, msg.id);\n\n        const streamer = new TextStreamer(pipe.tokenizer, {\n            skip_prompt: true,\n            skip_special_tokens: true,\n            callback_function: (text: string) => {\n                if (text) post({ type: 'gen-chunk', id: msg.id, chunkType: 'text', delta: text });\n            },\n        });\n\n        const temperature = msg.options.temperature ?? 0;\n        await pipe(msg.messages, {\n            max_new_tokens: msg.options.maxTokens ?? 512,\n            do_sample: temperature > 0,\n            temperature: temperature > 0 ? temperature : undefined,\n            streamer,\n            stopping_criteria: stoppingCriteria,\n        });\n\n        post({ type: 'gen-done', id: msg.id });\n    } catch (err) {\n        post({ type: 'gen-error', id: msg.id, message: (err as Error)?.message ?? 'Generation failed' });\n    } finally {\n        _activeStops.delete(msg.id);\n    }\n}\n\nctx.addEventListener('message', (event: MessageEvent<InMessage>) => {\n    const msg = event.data;\n    if (msg.type === 'prepare') void handlePrepare(msg);\n    else if (msg.type === 'generate') void handleGenerate(msg);\n    else if (msg.type === 'cancel') _activeStops.get(msg.id)?.interrupt();\n});\n"],"names":[],"mappings":";AAwBA,IAAI,mBAAmB;AACvB,IAAI,kBAAkB;AAKtB,MAAM,MAAM;AAYZ,SAAS,KAAK,SAAwB;AAClC,MAAI,YAAY,OAAO;AAC3B;AAEA,IAAI,WAAqE;AAIzE,MAAM,mCAAmB,IAAA;AAOzB,eAAe,eAAe,SAAiB,OAA0B,QAA4B,IAA8C;AAC/I,MAAI,UAAU,YAAY,QAAS,QAAO,SAAS;AAGnD,QAAM,OAA4B;AAAA,IAC9B,mBAAmB,CAAC,MAA6D;AAC7E,UAAI,CAAC,GAAI;AACT,UAAI,EAAE,WAAW,YAAY;AACzB,aAAK,EAAE,MAAM,YAAY,IAAI,QAAQ,eAAe,MAAM,EAAE,MAAM,UAAU,KAAK,MAAM,EAAE,YAAY,CAAC,GAAG;AAAA,MAC7G,WAAW,EAAE,WAAW,QAAQ;AAC5B,aAAK,EAAE,MAAM,YAAY,IAAI,QAAQ,WAAW,MAAM,EAAE,MAAM;AAAA,MAClE;AAAA,IACJ;AAAA,EAAA;AAEJ,MAAI,MAAO,MAAK,OAAO,IAAI;AAC3B,MAAI,UAAU,WAAW,OAAQ,MAAK,QAAQ,IAAI;AAElD,QAAM,OAAO,MAAM,SAAS,mBAAmB,SAAS,IAAI;AAC5D,aAAW,EAAE,SAAS,KAAA;AACtB,OAAK,EAAE,MAAM,kBAAkB,QAAA,CAAS;AACxC,SAAO;AACX;AAEA,eAAe,cAAc,KAA6D;AACtF,MAAI;AACA,UAAM,eAAe,IAAI,SAAS,IAAI,OAAO,IAAI,QAAQ,IAAI,EAAE;AAC/D,SAAK,EAAE,MAAM,YAAY,IAAI,IAAI,IAAI,QAAQ,SAAS;AAAA,EAC1D,SAAS,KAAK;AACV,SAAK,EAAE,MAAM,iBAAiB,IAAI,IAAI,IAAI,SAAU,KAAe,WAAW,uBAAA,CAAwB;AAAA,EAC1G;AACJ;AAEA,eAAe,eAAe,KAA8D;AACxF,QAAM,mBAAmB,IAAI,8BAAA;AAC7B,eAAa,IAAI,IAAI,IAAI,gBAAgB;AACzC,MAAI;AACA,UAAM,OAAO,MAAM,eAAe,IAAI,SAAS,IAAI,OAAO,IAAI,QAAQ,IAAI,EAAE;AAE5E,UAAM,WAAW,IAAI,aAAa,KAAK,WAAW;AAAA,MAC9C,aAAa;AAAA,MACb,qBAAqB;AAAA,MACrB,mBAAmB,CAAC,SAAiB;AACjC,YAAI,KAAM,MAAK,EAAE,MAAM,aAAa,IAAI,IAAI,IAAI,WAAW,QAAQ,OAAO,KAAA,CAAM;AAAA,MACpF;AAAA,IAAA,CACH;AAED,UAAM,cAAc,IAAI,QAAQ,eAAe;AAC/C,UAAM,KAAK,IAAI,UAAU;AAAA,MACrB,gBAAgB,IAAI,QAAQ,aAAa;AAAA,MACzC,WAAW,cAAc;AAAA,MACzB,aAAa,cAAc,IAAI,cAAc;AAAA,MAC7C;AAAA,MACA,mBAAmB;AAAA,IAAA,CACtB;AAED,SAAK,EAAE,MAAM,YAAY,IAAI,IAAI,IAAI;AAAA,EACzC,SAAS,KAAK;AACV,SAAK,EAAE,MAAM,aAAa,IAAI,IAAI,IAAI,SAAU,KAAe,WAAW,oBAAA,CAAqB;AAAA,EACnG,UAAA;AACI,iBAAa,OAAO,IAAI,EAAE;AAAA,EAC9B;AACJ;AAEA,IAAI,iBAAiB,WAAW,CAAC,UAAmC;AAChE,QAAM,MAAM,MAAM;AAClB,MAAI,IAAI,SAAS,UAAW,MAAK,cAAc,GAAG;AAAA,WACzC,IAAI,SAAS,WAAY,MAAK,eAAe,GAAG;AAAA,WAChD,IAAI,SAAS,SAAU,cAAa,IAAI,IAAI,EAAE,GAAG,UAAA;AAC9D,CAAC;"}

package/dist/index.d.ts

@@ -0,0 +1,88 @@
+/**
+ * @aparte/provider-transformers — run LLMs 100% in the browser via Transformers.js.
+ *
+ * A local, keyless `AparteAIProvider`: it owns its I/O (inference runs off the main
+ * thread in a Web Worker) so `DirectTransport` delegates to its `chat()`. Model
+ * weights download once and persist in the Cache API.
+ *
+ * Scope (v1): generic **text-generation** streaming. Tool-calling for local models is
+ * model-specific (every family has its own wire format) and is out of scope here — the
+ * app registers models and streams plain replies. Vision / embeddings can follow on demand.
+ */
+import type { AparteAIProvider, AparteAIModel } from '@aparte/core';
+export interface HardwareProfile {
+    hasGpu: boolean;
+    ramGb: number;
+    tier: 'low' | 'mid' | 'high';
+    recommendedModelId: string;
+}
+/**
+ * Set the model IDs to use per hardware tier. Call before detectHardware() is used
+ * to pick a default model — the provider ships no model knowledge of its own.
+ */
+export declare function setHardwareTierModels(tiers: {
+    low: string;
+    mid?: string;
+    high: string;
+}): void;
+export declare function detectHardware(): Promise<HardwareProfile>;
+/** Configuration for a model registered with the provider. */
+export interface TransformersModelConfig {
+    id: string;
+    name: string;
+    description?: string;
+    capabilities: AparteAIModel['capabilities'];
+    /** Transformers.js pipeline task — determines the model architecture / load path. */
+    task: 'text-generation';
+    /** ONNX dtype or per-part dtype map (e.g. `'q4'` or `{ decoder_model_merged: 'q4' }`). */
+    dtype?: string | Record<string, string>;
+    /** Preferred device. Defaults to WebGPU when available, else WASM. */
+    device?: 'webgpu' | 'wasm' | 'auto';
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Register a model with the provider. Call before the model is used for inference.
+ */
+export declare function registerModel(config: TransformersModelConfig): void;
+/**
+ * Set the maximum number of models to keep in cache. When exceeded after a new
+ * model is ready, the oldest models are evicted. 0 = unlimited.
+ */
+export declare function setMaxCachedModels(max: number): void;
+/** Returns the current max-cached-models setting. */
+export declare function getMaxCachedModels(): number;
+/**
+ * User's preferred compute backend for local inference.
+ *   'auto'   → WebGPU when available, else WASM (default)
+ *   'webgpu' → force WebGPU
+ *   'wasm'   → force WASM CPU
+ */
+export type ComputeDevice = 'auto' | 'webgpu' | 'wasm';
+export declare function setComputeDevice(d: ComputeDevice): void;
+export declare function getComputeDevice(): ComputeDevice;
+export declare const TransformersProvider: AparteAIProvider;
+export default TransformersProvider;
+export type { AparteAIProvider, AparteAIModel, ModelStatus, ModelLoadProgress } from '@aparte/core';
+/** Returns the modelId currently loaded in the worker's pipeline, or null. */
+export declare function getLoadedModelId(): string | null;
+/** Terminate the shared worker and reset in-memory state. Safe to call any time. */
+export declare function terminateWorker(): void;
+export interface CachedModelEntry {
+    modelId: string;
+    name: string;
+    /** Total size in bytes of all cached files for this model. -1 if unknown. */
+    sizeBytes: number;
+    /** True if the model is currently loaded in the worker. */
+    loaded: boolean;
+}
+/**
+ * Scan the Cache API to find which Transformers.js models have been downloaded,
+ * by matching cache entry URLs against the Hugging Face resolve path.
+ */
+export declare function listCachedModels(): Promise<CachedModelEntry[]>;
+/**
+ * Delete all cached files for a modelId from the Cache API, terminating the worker
+ * first if that model is currently loaded.
+ */
+export declare function deleteCachedModel(modelId: string): Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EACR,gBAAgB,EAChB,aAAa,EAMhB,MAAM,cAAc,CAAC;AAUtB,MAAM,WAAW,eAAe;IAC5B,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC7B,kBAAkB,EAAE,MAAM,CAAC;CAC9B;AAKD;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAE9F;AAED,wBAAsB,cAAc,IAAI,OAAO,CAAC,eAAe,CAAC,CA8B/D;AAMD,8DAA8D;AAC9D,MAAM,WAAW,uBAAuB;IACpC,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,CAAC;IAC5C,qFAAqF;IACrF,IAAI,EAAE,iBAAiB,CAAC;IACxB,0FAA0F;IAC1F,KAAK,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACxC,sEAAsE;IACtE,MAAM,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,MAAM,CAAC;IACpC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACtC;AAQD;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,uBAAuB,GAAG,IAAI,CAUnE;AAaD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAEpD;AAED,qDAAqD;AACrD,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,QAAQ,GAAG,MAAM,CAAC;AAGvD,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,aAAa,GAAG,IAAI,CAEvD;AAED,wBAAgB,gBAAgB,IAAI,aAAa,CAEhD;AAsLD,eAAO,MAAM,oBAAoB,EAAE,gBAiIlC,CAAC;AAEF,eAAe,oBAAoB,CAAC;AACpC,YAAY,EAAE,gBAAgB,EAAE,aAAa,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAMpG,8EAA8E;AAC9E,wBAAgB,gBAAgB,IAAI,MAAM,GAAG,IAAI,CAEhD;AAED,oFAAoF;AACpF,wBAAgB,eAAe,IAAI,IAAI,CAatC;AAED,MAAM,WAAW,gBAAgB;IAC7B,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,SAAS,EAAE,MAAM,CAAC;IAClB,2DAA2D;IAC3D,MAAM,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAsB,gBAAgB,IAAI,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAsDpE;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBtE"}

package/dist/index.js

@@ -0,0 +1,432 @@
+import { contentToText } from "@aparte/core";
+let _hardwareTiers = null;
+function setHardwareTierModels(tiers) {
+  _hardwareTiers = tiers;
+}
+async function detectHardware() {
+  const ramGb = navigator.deviceMemory ?? 4;
+  let hasGpu = false;
+  if ("gpu" in navigator) {
+    try {
+      const adapter = await navigator.gpu.requestAdapter();
+      hasGpu = adapter !== null;
+    } catch {
+      hasGpu = false;
+    }
+  }
+  let tier;
+  if (!hasGpu || ramGb < 4) {
+    tier = "low";
+  } else if (ramGb < 8) {
+    tier = "mid";
+  } else {
+    tier = "high";
+  }
+  const recommendedModelId = _hardwareTiers ? _hardwareTiers[tier] ?? _hardwareTiers.high ?? "" : "";
+  return { hasGpu, ramGb, tier, recommendedModelId };
+}
+const _registeredModels = /* @__PURE__ */ new Map();
+let _knownModels = [];
+function registerModel(config) {
+  _registeredModels.set(config.id, config);
+  if (!_knownModels.find((m) => m.id === config.id)) {
+    _knownModels = [..._knownModels, {
+      id: config.id,
+      name: config.name,
+      description: config.description,
+      capabilities: config.capabilities
+    }];
+  }
+}
+function _modelFromCacheEntry(modelId) {
+  const config = _registeredModels.get(modelId);
+  if (config) return { id: config.id, name: config.name, description: config.description, capabilities: config.capabilities };
+  const name = (modelId.split("/").pop() ?? modelId).replace(/-/g, " ");
+  return { id: modelId, name, capabilities: ["streaming"] };
+}
+let _maxCachedModels = 1;
+function setMaxCachedModels(max) {
+  _maxCachedModels = max;
+}
+function getMaxCachedModels() {
+  return _maxCachedModels;
+}
+let _computeDevice = "auto";
+function setComputeDevice(d) {
+  _computeDevice = d;
+}
+function getComputeDevice() {
+  return _computeDevice;
+}
+async function _enforceMaxCachedModels(keepModelId) {
+  if (_maxCachedModels === 0) return;
+  try {
+    const cached = await listCachedModels();
+    const others = cached.filter((e) => e.modelId !== keepModelId);
+    const excess = cached.length - _maxCachedModels;
+    if (excess <= 0) return;
+    for (let i = 0; i < excess && i < others.length; i++) {
+      await deleteCachedModel(others[i].modelId);
+    }
+  } catch {
+  }
+}
+async function _refreshKnownModels() {
+  try {
+    const cached = await listCachedModels();
+    for (const entry of cached) {
+      if (!_knownModels.find((m) => m.id === entry.modelId)) {
+        _knownModels = [..._knownModels, _modelFromCacheEntry(entry.modelId)];
+      }
+    }
+  } catch {
+  }
+}
+function toMessages(messages) {
+  const result = [];
+  for (const m of messages) {
+    if (m.role === "user" || m.role === "assistant" || m.role === "system") {
+      const text = contentToText(m.content);
+      if (text) result.push({ role: m.role, content: text });
+    }
+  }
+  return result;
+}
+let _worker = null;
+const _pendingPrepares = /* @__PURE__ */ new Map();
+const _pendingGenerates = /* @__PURE__ */ new Map();
+let _generateChain = Promise.resolve();
+const _generateDoneResolvers = /* @__PURE__ */ new Map();
+function _releaseGenerateSlot(id) {
+  const resolve = _generateDoneResolvers.get(id);
+  if (resolve) {
+    _generateDoneResolvers.delete(id);
+    resolve();
+  }
+}
+let _loadedModelId = null;
+let _preparingModelId = null;
+function _getWorker() {
+  if (!_worker) {
+    _worker = new Worker(new URL(
+      /* @vite-ignore */
+      "" + new URL("assets/worker-Bk-8pt3W.js", import.meta.url).href,
+      import.meta.url
+    ), { type: "module" });
+    _worker.addEventListener("message", _handleWorkerMessage);
+    _worker.addEventListener("error", _handleWorkerError);
+    _worker.addEventListener("messageerror", _handleWorkerError);
+  }
+  return _worker;
+}
+function _handleWorkerError(e) {
+  const message = e?.message || "Worker crashed unexpectedly";
+  for (const p of _pendingPrepares.values()) {
+    try {
+      p.reject(new Error(message));
+    } catch {
+    }
+  }
+  _pendingPrepares.clear();
+  for (const ctrl of _pendingGenerates.values()) {
+    try {
+      ctrl.enqueue({ type: "error", message });
+      ctrl.close();
+    } catch {
+    }
+  }
+  _pendingGenerates.clear();
+  for (const resolve of _generateDoneResolvers.values()) {
+    try {
+      resolve();
+    } catch {
+    }
+  }
+  _generateDoneResolvers.clear();
+  _generateChain = Promise.resolve();
+  _loadedModelId = null;
+  _preparingModelId = null;
+  try {
+    _worker?.terminate();
+  } catch {
+  }
+  _worker = null;
+}
+function _handleWorkerMessage(event) {
+  const msg = event.data;
+  switch (msg.type) {
+    case "progress": {
+      const pending = _pendingPrepares.get(msg.id);
+      if (!pending) break;
+      if (msg.status === "ready") {
+        pending.onProgress({ status: "ready" });
+        pending.resolve();
+        _pendingPrepares.delete(msg.id);
+      } else if (msg.status === "loading") {
+        pending.onProgress({ status: "loading" });
+      } else if (msg.status === "cached") {
+        pending.onProgress({ status: "cached", file: msg.file, progress: msg.progress });
+      } else {
+        pending.onProgress({ status: "downloading", file: msg.file, progress: msg.progress });
+      }
+      break;
+    }
+    case "prepare-error": {
+      const pending = _pendingPrepares.get(msg.id);
+      if (!pending) break;
+      pending.reject(new Error(msg.message));
+      _pendingPrepares.delete(msg.id);
+      if (_preparingModelId === pending.modelId) _preparingModelId = null;
+      break;
+    }
+    case "pipeline-ready": {
+      _loadedModelId = msg.modelId;
+      _preparingModelId = null;
+      void _enforceMaxCachedModels(msg.modelId).then(() => _refreshKnownModels());
+      break;
+    }
+    case "gen-chunk": {
+      const ctrl = _pendingGenerates.get(msg.id);
+      if (!ctrl) break;
+      ctrl.enqueue({ type: msg.chunkType, delta: msg.delta });
+      break;
+    }
+    case "gen-done": {
+      _releaseGenerateSlot(msg.id);
+      const ctrl = _pendingGenerates.get(msg.id);
+      if (!ctrl) break;
+      ctrl.enqueue({ type: "done", ...msg.usage ? { usage: msg.usage } : {} });
+      ctrl.close();
+      _pendingGenerates.delete(msg.id);
+      break;
+    }
+    case "gen-error": {
+      _releaseGenerateSlot(msg.id);
+      const ctrl = _pendingGenerates.get(msg.id);
+      if (!ctrl) break;
+      ctrl.enqueue({ type: "error", message: msg.message });
+      ctrl.close();
+      _pendingGenerates.delete(msg.id);
+      break;
+    }
+  }
+}
+const TransformersProvider = {
+  id: "transformers",
+  getMetadata() {
+    return {
+      id: "transformers",
+      name: "Transformers.js",
+      icon: `<svg viewBox="0 0 24 24" fill="none" xmlns="http://www.w3.org/2000/svg"><path d="M12 2L2 7l10 5 10-5-10-5z" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/><path d="M2 17l10 5 10-5" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/><path d="M2 12l10 5 10-5" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>`,
+      color: "#f59e0b",
+      description: "Run LLMs directly in your browser via WebGPU or WASM — no API, no key",
+      hasFreeModels: true,
+      isLocal: true,
+      helpUrl: "https://huggingface.co/docs/transformers.js"
+    };
+  },
+  getModels() {
+    return _knownModels;
+  },
+  async fetchModels() {
+    await _refreshKnownModels();
+    return _knownModels;
+  },
+  async chat(request) {
+    const messages = toMessages(request.messages);
+    const requestId = crypto.randomUUID();
+    const options = {
+      maxTokens: request.maxTokens,
+      temperature: request.temperature,
+      seed: request.seed
+    };
+    const task = _registeredModels.get(request.modelId)?.task ?? "text-generation";
+    const prevGenerate = _generateChain;
+    _generateChain = new Promise((resolveSlot) => {
+      _generateDoneResolvers.set(requestId, resolveSlot);
+    });
+    const postGenerate = () => {
+      _getWorker().postMessage({
+        type: "generate",
+        id: requestId,
+        modelId: request.modelId,
+        messages,
+        options,
+        task,
+        dtype: _registeredModels.get(request.modelId)?.dtype,
+        device: _computeDevice
+      });
+    };
+    if (request.stream === false) {
+      return new Promise((resolve, reject) => {
+        let result = "";
+        const fakeCtrl = {
+          enqueue: (chunk) => {
+            if (chunk.type === "text") result += chunk.delta ?? "";
+            else if (chunk.type === "done") resolve(result);
+            else if (chunk.type === "error") reject(new Error(chunk.message));
+          },
+          close: () => {
+          }
+        };
+        _pendingGenerates.set(requestId, fakeCtrl);
+        void prevGenerate.then(postGenerate);
+      });
+    }
+    return new ReadableStream({
+      async start(controller) {
+        _pendingGenerates.set(requestId, controller);
+        await prevGenerate;
+        postGenerate();
+      },
+      cancel() {
+        _pendingGenerates.delete(requestId);
+        _getWorker().postMessage({ type: "cancel", id: requestId });
+      }
+    });
+  },
+  async getModelStatus(modelId) {
+    if (_loadedModelId === modelId) return "ready";
+    if (_preparingModelId === modelId) return "cached";
+    if ("caches" in globalThis) {
+      try {
+        const encodedId = encodeURIComponent(modelId);
+        const names = await caches.keys();
+        for (const name of names) {
+          const cache = await caches.open(name);
+          const keys = await cache.keys();
+          if (keys.some((r) => r.url.includes(encodedId) || r.url.includes(modelId + "/"))) {
+            return "cached";
+          }
+        }
+      } catch {
+      }
+    }
+    return "not-downloaded";
+  },
+  async prepareModel(modelId, onProgress) {
+    if (_loadedModelId === modelId) {
+      onProgress({ status: "ready" });
+      return;
+    }
+    const requestId = crypto.randomUUID();
+    _preparingModelId = modelId;
+    const task = _registeredModels.get(modelId)?.task ?? "text-generation";
+    const dtype = _registeredModels.get(modelId)?.dtype;
+    return new Promise((resolve, reject) => {
+      _pendingPrepares.set(requestId, { modelId, onProgress, resolve, reject });
+      _getWorker().postMessage({ type: "prepare", id: requestId, modelId, task, dtype, device: _computeDevice });
+    });
+  },
+  async deleteModel(modelId) {
+    await deleteCachedModel(modelId);
+  }
+};
+function getLoadedModelId() {
+  return _loadedModelId;
+}
+function terminateWorker() {
+  _worker?.terminate();
+  _worker = null;
+  _loadedModelId = null;
+  _preparingModelId = null;
+  for (const [, p] of _pendingPrepares) {
+    p.reject(new Error("Worker terminated"));
+  }
+  _pendingPrepares.clear();
+  for (const [, ctrl] of _pendingGenerates) {
+    try {
+      ctrl.enqueue({ type: "error", message: "Worker terminated" });
+      ctrl.close();
+    } catch {
+    }
+  }
+  _pendingGenerates.clear();
+}
+async function listCachedModels() {
+  if (!("caches" in globalThis)) return [];
+  const found = /* @__PURE__ */ new Map();
+  function extractModelId(url) {
+    const m = url.match(/huggingface\.co\/([^/]+\/[^/]+)\/resolve\//);
+    return m ? decodeURIComponent(m[1]) : null;
+  }
+  function modelName(modelId) {
+    const config = _registeredModels.get(modelId);
+    if (config) return config.name;
+    return (modelId.split("/").pop() ?? modelId).replace(/-/g, " ");
+  }
+  try {
+    const cacheNames = await caches.keys();
+    await Promise.all(cacheNames.map(async (cacheName) => {
+      try {
+        const cache = await caches.open(cacheName);
+        const requests = await cache.keys();
+        for (const req of requests) {
+          const modelId = extractModelId(req.url);
+          if (!modelId) continue;
+          if (!found.has(modelId)) {
+            found.set(modelId, { name: modelName(modelId), sizeBytes: 0 });
+          }
+          const response = await cache.match(req);
+          if (!response) continue;
+          const contentLength = response.headers.get("content-length");
+          if (contentLength) {
+            found.get(modelId).sizeBytes += parseInt(contentLength, 10);
+          } else {
+            try {
+              const blob = await response.clone().blob();
+              found.get(modelId).sizeBytes += blob.size;
+            } catch {
+            }
+          }
+        }
+      } catch {
+      }
+    }));
+  } catch {
+    return [];
+  }
+  return Array.from(found.entries()).map(([modelId, { name, sizeBytes }]) => ({
+    modelId,
+    name,
+    sizeBytes,
+    loaded: _loadedModelId === modelId
+  }));
+}
+async function deleteCachedModel(modelId) {
+  if (_loadedModelId === modelId || _preparingModelId === modelId) {
+    terminateWorker();
+  }
+  if (!("caches" in globalThis)) return;
+  try {
+    const cacheNames = await caches.keys();
+    await Promise.all(cacheNames.map(async (cacheName) => {
+      try {
+        const cache = await caches.open(cacheName);
+        const requests = await cache.keys();
+        const encoded = encodeURIComponent(modelId);
+        await Promise.all(
+          requests.filter((r) => r.url.includes(modelId) || r.url.includes(encoded)).map((r) => cache.delete(r))
+        );
+      } catch {
+      }
+    }));
+  } catch {
+  }
+}
+export {
+  TransformersProvider,
+  TransformersProvider as default,
+  deleteCachedModel,
+  detectHardware,
+  getComputeDevice,
+  getLoadedModelId,
+  getMaxCachedModels,
+  listCachedModels,
+  registerModel,
+  setComputeDevice,
+  setHardwareTierModels,
+  setMaxCachedModels,
+  terminateWorker
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../src/index.ts"],"sourcesContent":["/**\n * @aparte/provider-transformers — run LLMs 100% in the browser via Transformers.js.\n *\n * A local, keyless `AparteAIProvider`: it owns its I/O (inference runs off the main\n * thread in a Web Worker) so `DirectTransport` delegates to its `chat()`. Model\n * weights download once and persist in the Cache API.\n *\n * Scope (v1): generic **text-generation** streaming. Tool-calling for local models is\n * model-specific (every family has its own wire format) and is out of scope here — the\n * app registers models and streams plain replies. Vision / embeddings can follow on demand.\n */\n\nimport type {\n    AparteAIProvider,\n    AparteAIModel,\n    AparteChatRequest,\n    AparteChatResponse,\n    AparteChatMessage,\n    ModelStatus,\n    ModelLoadProgress,\n} from '@aparte/core';\nimport { contentToText } from '@aparte/core';\n\n/** The minimal chat shape passed to the worker (the tokenizer applies the chat template). */\ntype SimpleMessage = { role: 'user' | 'assistant' | 'system'; content: string };\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Hardware detection\n// ─────────────────────────────────────────────────────────────────────────────\n\nexport interface HardwareProfile {\n    hasGpu: boolean;\n    ramGb: number;\n    tier: 'low' | 'mid' | 'high';\n    recommendedModelId: string;\n}\n\n/** Hardware-tier model overrides — set by the app via setHardwareTierModels(). */\nlet _hardwareTiers: { low: string; mid?: string; high: string } | null = null;\n\n/**\n * Set the model IDs to use per hardware tier. Call before detectHardware() is used\n * to pick a default model — the provider ships no model knowledge of its own.\n */\nexport function setHardwareTierModels(tiers: { low: string; mid?: string; high: string }): void {\n    _hardwareTiers = tiers;\n}\n\nexport async function detectHardware(): Promise<HardwareProfile> {\n    // navigator.deviceMemory: W3C API, Chromium only, capped at 8 GB for privacy\n    // (1 | 2 | 4 | 8). Falls back to 4 on Firefox/Safari.\n    const ramGb: number = (navigator as unknown as { deviceMemory?: number }).deviceMemory ?? 4;\n\n    // Real WebGPU check: requestAdapter() returns null if no capable GPU is present.\n    let hasGpu = false;\n    if ('gpu' in navigator) {\n        try {\n            const adapter = await (navigator as unknown as { gpu: { requestAdapter(): Promise<unknown> } }).gpu.requestAdapter();\n            hasGpu = adapter !== null;\n        } catch {\n            hasGpu = false;\n        }\n    }\n\n    let tier: 'low' | 'mid' | 'high';\n    if (!hasGpu || ramGb < 4) {\n        tier = 'low';\n    } else if (ramGb < 8) {\n        tier = 'mid';\n    } else {\n        tier = 'high';\n    }\n\n    const recommendedModelId = _hardwareTiers\n        ? (_hardwareTiers[tier] ?? _hardwareTiers.high ?? '')\n        : '';\n\n    return { hasGpu, ramGb, tier, recommendedModelId };\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Model catalog — all model knowledge lives in the app, not the provider.\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Configuration for a model registered with the provider. */\nexport interface TransformersModelConfig {\n    id: string;\n    name: string;\n    description?: string;\n    capabilities: AparteAIModel['capabilities'];\n    /** Transformers.js pipeline task — determines the model architecture / load path. */\n    task: 'text-generation';\n    /** ONNX dtype or per-part dtype map (e.g. `'q4'` or `{ decoder_model_merged: 'q4' }`). */\n    dtype?: string | Record<string, string>;\n    /** Preferred device. Defaults to WebGPU when available, else WASM. */\n    device?: 'webgpu' | 'wasm' | 'auto';\n    metadata?: Record<string, unknown>;\n}\n\n/** Models registered by the app via registerModel(). */\nconst _registeredModels = new Map<string, TransformersModelConfig>();\n\n/** Mutable model list — populated by registerModel() and cache discovery. */\nlet _knownModels: AparteAIModel[] = [];\n\n/**\n * Register a model with the provider. Call before the model is used for inference.\n */\nexport function registerModel(config: TransformersModelConfig): void {\n    _registeredModels.set(config.id, config);\n    if (!_knownModels.find(m => m.id === config.id)) {\n        _knownModels = [..._knownModels, {\n            id: config.id,\n            name: config.name,\n            description: config.description,\n            capabilities: config.capabilities,\n        }];\n    }\n}\n\n/** Build an AparteAIModel entry from a cache-discovered modelId not in the registry. */\nfunction _modelFromCacheEntry(modelId: string): AparteAIModel {\n    const config = _registeredModels.get(modelId);\n    if (config) return { id: config.id, name: config.name, description: config.description, capabilities: config.capabilities };\n    const name = (modelId.split('/').pop() ?? modelId).replace(/-/g, ' ');\n    return { id: modelId, name, capabilities: ['streaming'] };\n}\n\n/** Max number of models to keep in cache. 0 = unlimited. Default: 1. */\nlet _maxCachedModels = 1;\n\n/**\n * Set the maximum number of models to keep in cache. When exceeded after a new\n * model is ready, the oldest models are evicted. 0 = unlimited.\n */\nexport function setMaxCachedModels(max: number): void {\n    _maxCachedModels = max;\n}\n\n/** Returns the current max-cached-models setting. */\nexport function getMaxCachedModels(): number {\n    return _maxCachedModels;\n}\n\n/**\n * User's preferred compute backend for local inference.\n *   'auto'   → WebGPU when available, else WASM (default)\n *   'webgpu' → force WebGPU\n *   'wasm'   → force WASM CPU\n */\nexport type ComputeDevice = 'auto' | 'webgpu' | 'wasm';\nlet _computeDevice: ComputeDevice = 'auto';\n\nexport function setComputeDevice(d: ComputeDevice): void {\n    _computeDevice = d;\n}\n\nexport function getComputeDevice(): ComputeDevice {\n    return _computeDevice;\n}\n\n/** Evict models from cache until count <= _maxCachedModels; `keepModelId` is never evicted. */\nasync function _enforceMaxCachedModels(keepModelId: string): Promise<void> {\n    if (_maxCachedModels === 0) return; // unlimited\n    try {\n        const cached = await listCachedModels();\n        const others = cached.filter(e => e.modelId !== keepModelId);\n        const excess = cached.length - _maxCachedModels;\n        if (excess <= 0) return;\n        // Delete the excess models (oldest first — they appear first in cache scan order).\n        for (let i = 0; i < excess && i < others.length; i++) {\n            await deleteCachedModel(others[i]!.modelId);\n        }\n    } catch { /* cache unavailable */ }\n}\n\n/** Merge cached models into _knownModels (idempotent). Called by fetchModels(). */\nasync function _refreshKnownModels(): Promise<void> {\n    try {\n        const cached = await listCachedModels();\n        for (const entry of cached) {\n            if (!_knownModels.find(m => m.id === entry.modelId)) {\n                _knownModels = [..._knownModels, _modelFromCacheEntry(entry.modelId)];\n            }\n        }\n    } catch { /* cache unavailable */ }\n}\n\n/** AparteChatMessage[] → plain chat turns (the tokenizer's chat template does the rest). */\nfunction toMessages(messages: AparteChatMessage[]): SimpleMessage[] {\n    const result: SimpleMessage[] = [];\n    for (const m of messages) {\n        if (m.role === 'user' || m.role === 'assistant' || m.role === 'system') {\n            const text = contentToText(m.content);\n            if (text) result.push({ role: m.role, content: text });\n        }\n        // tool_call / tool_result are not supported by this generic provider (v1).\n    }\n    return result;\n}\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Worker bridge\n// ─────────────────────────────────────────────────────────────────────────────\n\nlet _worker: Worker | null = null;\n\ninterface PendingPrepare {\n    modelId: string;\n    onProgress: (p: ModelLoadProgress) => void;\n    resolve: () => void;\n    reject: (err: Error) => void;\n}\nconst _pendingPrepares = new Map<string, PendingPrepare>();\nconst _pendingGenerates = new Map<string, ReadableStreamDefaultController>();\n\n// ── Generate serialization ──────────────────────────────────────────────────\n// The worker holds ONE pipeline: two concurrent generates would corrupt each\n// other. Each chat() chains its `generate` behind the previous generate's\n// completion (gen-done / gen-error).\nlet _generateChain: Promise<void> = Promise.resolve();\nconst _generateDoneResolvers = new Map<string, () => void>();\n\n/** Settle the serialization slot for a finished generate. */\nfunction _releaseGenerateSlot(id: string): void {\n    const resolve = _generateDoneResolvers.get(id);\n    if (resolve) {\n        _generateDoneResolvers.delete(id);\n        resolve();\n    }\n}\n\n/** Model known to be loaded (main-thread view). */\nlet _loadedModelId: string | null = null;\n/** Model currently being prepared (for the getModelStatus 'cached' path). */\nlet _preparingModelId: string | null = null;\n\nfunction _getWorker(): Worker {\n    if (!_worker) {\n        _worker = new Worker(new URL('./worker.ts', import.meta.url), { type: 'module' });\n        _worker.addEventListener('message', _handleWorkerMessage);\n        _worker.addEventListener('error', _handleWorkerError);\n        _worker.addEventListener('messageerror', _handleWorkerError);\n    }\n    return _worker;\n}\n\n/**\n * Worker crashed (uncaught error / WASM init failure / OOM). Reject every in-flight\n * prepare and close every open generate stream so the UI doesn't hang. Subsequent\n * calls rebuild the worker.\n */\nfunction _handleWorkerError(e: Event): void {\n    const message = (e as ErrorEvent)?.message || 'Worker crashed unexpectedly';\n\n    for (const p of _pendingPrepares.values()) {\n        try { p.reject(new Error(message)); } catch { /* ignore */ }\n    }\n    _pendingPrepares.clear();\n\n    for (const ctrl of _pendingGenerates.values()) {\n        try { ctrl.enqueue({ type: 'error' as const, message }); ctrl.close(); }\n        catch { /* ignore */ }\n    }\n    _pendingGenerates.clear();\n\n    // Release every serialization slot so the generate chain doesn't deadlock.\n    for (const resolve of _generateDoneResolvers.values()) {\n        try { resolve(); } catch { /* ignore */ }\n    }\n    _generateDoneResolvers.clear();\n    _generateChain = Promise.resolve();\n\n    _loadedModelId = null;\n    _preparingModelId = null;\n    try { _worker?.terminate(); } catch { /* ignore */ }\n    _worker = null;\n}\n\nfunction _handleWorkerMessage(event: MessageEvent): void {\n    const msg = event.data;\n\n    switch (msg.type) {\n        case 'progress': {\n            const pending = _pendingPrepares.get(msg.id);\n            if (!pending) break;\n            if (msg.status === 'ready') {\n                pending.onProgress({ status: 'ready' });\n                pending.resolve();\n                _pendingPrepares.delete(msg.id);\n            } else if (msg.status === 'loading') {\n                pending.onProgress({ status: 'loading' });\n            } else if (msg.status === 'cached') {\n                pending.onProgress({ status: 'cached', file: msg.file, progress: msg.progress });\n            } else {\n                pending.onProgress({ status: 'downloading', file: msg.file, progress: msg.progress });\n            }\n            break;\n        }\n        case 'prepare-error': {\n            const pending = _pendingPrepares.get(msg.id);\n            if (!pending) break;\n            pending.reject(new Error(msg.message));\n            _pendingPrepares.delete(msg.id);\n            if (_preparingModelId === pending.modelId) _preparingModelId = null;\n            break;\n        }\n        case 'pipeline-ready': {\n            _loadedModelId = msg.modelId;\n            _preparingModelId = null;\n            // Evict models over the cache limit, then refresh the known list.\n            void _enforceMaxCachedModels(msg.modelId).then(() => _refreshKnownModels());\n            break;\n        }\n        case 'gen-chunk': {\n            const ctrl = _pendingGenerates.get(msg.id);\n            if (!ctrl) break;\n            ctrl.enqueue({ type: msg.chunkType as 'text' | 'thinking', delta: msg.delta });\n            break;\n        }\n        case 'gen-done': {\n            _releaseGenerateSlot(msg.id);\n            const ctrl = _pendingGenerates.get(msg.id);\n            if (!ctrl) break;\n            ctrl.enqueue({ type: 'done' as const, ...(msg.usage ? { usage: msg.usage } : {}) });\n            ctrl.close();\n            _pendingGenerates.delete(msg.id);\n            break;\n        }\n        case 'gen-error': {\n            _releaseGenerateSlot(msg.id);\n            const ctrl = _pendingGenerates.get(msg.id);\n            if (!ctrl) break;\n            ctrl.enqueue({ type: 'error' as const, message: msg.message });\n            ctrl.close();\n            _pendingGenerates.delete(msg.id);\n            break;\n        }\n    }\n}\n\nexport const TransformersProvider: AparteAIProvider = {\n    id: 'transformers',\n\n    getMetadata() {\n        return {\n            id: 'transformers',\n            name: 'Transformers.js',\n            icon: `<svg viewBox=\"0 0 24 24\" fill=\"none\" xmlns=\"http://www.w3.org/2000/svg\"><path d=\"M12 2L2 7l10 5 10-5-10-5z\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 17l10 5 10-5\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/><path d=\"M2 12l10 5 10-5\" stroke=\"currentColor\" stroke-width=\"2\" stroke-linecap=\"round\" stroke-linejoin=\"round\"/></svg>`,\n            color: '#f59e0b',\n            description: 'Run LLMs directly in your browser via WebGPU or WASM — no API, no key',\n            hasFreeModels: true,\n            isLocal: true,\n            helpUrl: 'https://huggingface.co/docs/transformers.js',\n        };\n    },\n\n    getModels(): AparteAIModel[] {\n        return _knownModels;\n    },\n\n    async fetchModels(): Promise<AparteAIModel[]> {\n        await _refreshKnownModels();\n        return _knownModels;\n    },\n\n    async chat(request: AparteChatRequest): Promise<AparteChatResponse> {\n        const messages = toMessages(request.messages);\n        const requestId = crypto.randomUUID();\n        const options = {\n            maxTokens: request.maxTokens,\n            temperature: request.temperature,\n            seed: request.seed,\n        };\n        const task = _registeredModels.get(request.modelId)?.task ?? 'text-generation';\n\n        // ── Reserve a serialization slot ─────────────────────────────────────\n        // Chain this generate behind the previous one; the worker has a single\n        // pipeline, so generates MUST NOT overlap.\n        const prevGenerate = _generateChain;\n        _generateChain = new Promise<void>((resolveSlot) => {\n            _generateDoneResolvers.set(requestId, resolveSlot);\n        });\n        const postGenerate = (): void => {\n            _getWorker().postMessage({\n                type: 'generate',\n                id: requestId,\n                modelId: request.modelId,\n                messages,\n                options,\n                task,\n                dtype: _registeredModels.get(request.modelId)?.dtype,\n                device: _computeDevice,\n            });\n        };\n\n        if (request.stream === false) {\n            return new Promise<string>((resolve, reject) => {\n                let result = '';\n                const fakeCtrl = {\n                    enqueue: (chunk: { type: string; delta?: string; message?: string }) => {\n                        if (chunk.type === 'text') result += chunk.delta ?? '';\n                        else if (chunk.type === 'done') resolve(result);\n                        else if (chunk.type === 'error') reject(new Error(chunk.message));\n                    },\n                    close: () => { /* no-op */ },\n                } as unknown as ReadableStreamDefaultController;\n                _pendingGenerates.set(requestId, fakeCtrl);\n                void prevGenerate.then(postGenerate);\n            });\n        }\n\n        return new ReadableStream({\n            async start(controller) {\n                _pendingGenerates.set(requestId, controller);\n                await prevGenerate;\n                postGenerate();\n            },\n            cancel() {\n                _pendingGenerates.delete(requestId);\n                // Actually STOP the model (not just detach the reader): tell the worker\n                // to interrupt this generate. The serialization slot is still released\n                // by the resulting gen-done/gen-error, so a queued generate can't start\n                // before the worker has stopped this one.\n                _getWorker().postMessage({ type: 'cancel', id: requestId });\n            },\n        });\n    },\n\n    async getModelStatus(modelId: string): Promise<ModelStatus> {\n        if (_loadedModelId === modelId) return 'ready';\n        if (_preparingModelId === modelId) return 'cached';\n        if ('caches' in globalThis) {\n            try {\n                const encodedId = encodeURIComponent(modelId);\n                const names = await caches.keys();\n                for (const name of names) {\n                    const cache = await caches.open(name);\n                    const keys = await cache.keys();\n                    if (keys.some(r => r.url.includes(encodedId) || r.url.includes(modelId + '/'))) {\n                        return 'cached';\n                    }\n                }\n            } catch {\n                // Cache API unavailable\n            }\n        }\n        return 'not-downloaded';\n    },\n\n    async prepareModel(modelId: string, onProgress: (p: ModelLoadProgress) => void): Promise<void> {\n        if (_loadedModelId === modelId) {\n            onProgress({ status: 'ready' });\n            return;\n        }\n\n        const requestId = crypto.randomUUID();\n        _preparingModelId = modelId;\n\n        const task = _registeredModels.get(modelId)?.task ?? 'text-generation';\n        const dtype = _registeredModels.get(modelId)?.dtype;\n        return new Promise<void>((resolve, reject) => {\n            _pendingPrepares.set(requestId, { modelId, onProgress, resolve, reject });\n            _getWorker().postMessage({ type: 'prepare', id: requestId, modelId, task, dtype, device: _computeDevice });\n        });\n    },\n\n    async deleteModel(modelId: string): Promise<void> {\n        await deleteCachedModel(modelId);\n    },\n};\n\nexport default TransformersProvider;\nexport type { AparteAIProvider, AparteAIModel, ModelStatus, ModelLoadProgress } from '@aparte/core';\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Cache utilities (settings panels, etc.)\n// ─────────────────────────────────────────────────────────────────────────────\n\n/** Returns the modelId currently loaded in the worker's pipeline, or null. */\nexport function getLoadedModelId(): string | null {\n    return _loadedModelId;\n}\n\n/** Terminate the shared worker and reset in-memory state. Safe to call any time. */\nexport function terminateWorker(): void {\n    _worker?.terminate();\n    _worker = null;\n    _loadedModelId = null;\n    _preparingModelId = null;\n    for (const [, p] of _pendingPrepares) {\n        p.reject(new Error('Worker terminated'));\n    }\n    _pendingPrepares.clear();\n    for (const [, ctrl] of _pendingGenerates) {\n        try { ctrl.enqueue({ type: 'error' as const, message: 'Worker terminated' }); ctrl.close(); } catch { /* already closed */ }\n    }\n    _pendingGenerates.clear();\n}\n\nexport interface CachedModelEntry {\n    modelId: string;\n    name: string;\n    /** Total size in bytes of all cached files for this model. -1 if unknown. */\n    sizeBytes: number;\n    /** True if the model is currently loaded in the worker. */\n    loaded: boolean;\n}\n\n/**\n * Scan the Cache API to find which Transformers.js models have been downloaded,\n * by matching cache entry URLs against the Hugging Face resolve path.\n */\nexport async function listCachedModels(): Promise<CachedModelEntry[]> {\n    if (!('caches' in globalThis)) return [];\n\n    const found = new Map<string, { name: string; sizeBytes: number }>();\n\n    // e.g. https://huggingface.co/onnx-community/Qwen2.5-0.5B/resolve/main/config.json\n    //   → onnx-community/Qwen2.5-0.5B\n    function extractModelId(url: string): string | null {\n        const m = url.match(/huggingface\\.co\\/([^/]+\\/[^/]+)\\/resolve\\//);\n        return m ? decodeURIComponent(m[1]!) : null;\n    }\n\n    function modelName(modelId: string): string {\n        const config = _registeredModels.get(modelId);\n        if (config) return config.name;\n        return (modelId.split('/').pop() ?? modelId).replace(/-/g, ' ');\n    }\n\n    try {\n        const cacheNames = await caches.keys();\n        await Promise.all(cacheNames.map(async (cacheName) => {\n            try {\n                const cache = await caches.open(cacheName);\n                const requests = await cache.keys();\n                for (const req of requests) {\n                    const modelId = extractModelId(req.url);\n                    if (!modelId) continue;\n                    if (!found.has(modelId)) {\n                        found.set(modelId, { name: modelName(modelId), sizeBytes: 0 });\n                    }\n                    const response = await cache.match(req);\n                    if (!response) continue;\n                    const contentLength = response.headers.get('content-length');\n                    if (contentLength) {\n                        found.get(modelId)!.sizeBytes += parseInt(contentLength, 10);\n                    } else {\n                        try {\n                            const blob = await response.clone().blob();\n                            found.get(modelId)!.sizeBytes += blob.size;\n                        } catch { /* skip */ }\n                    }\n                }\n            } catch { /* skip inaccessible cache */ }\n        }));\n    } catch {\n        return [];\n    }\n\n    return Array.from(found.entries()).map(([modelId, { name, sizeBytes }]) => ({\n        modelId,\n        name,\n        sizeBytes,\n        loaded: _loadedModelId === modelId,\n    }));\n}\n\n/**\n * Delete all cached files for a modelId from the Cache API, terminating the worker\n * first if that model is currently loaded.\n */\nexport async function deleteCachedModel(modelId: string): Promise<void> {\n    if (_loadedModelId === modelId || _preparingModelId === modelId) {\n        terminateWorker();\n    }\n    if (!('caches' in globalThis)) return;\n    try {\n        const cacheNames = await caches.keys();\n        await Promise.all(cacheNames.map(async (cacheName) => {\n            try {\n                const cache = await caches.open(cacheName);\n                const requests = await cache.keys();\n                const encoded = encodeURIComponent(modelId);\n                await Promise.all(\n                    requests\n                        .filter(r => r.url.includes(modelId) || r.url.includes(encoded))\n                        .map(r => cache.delete(r)),\n                );\n            } catch { /* skip */ }\n        }));\n    } catch { /* Cache API unavailable */ }\n}\n"],"names":[],"mappings":"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"}

package/dist/worker.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Generic Transformers.js inference worker.
+ *
+ * Runs entirely off the main thread. It holds ONE text-generation pipeline at a
+ * time and speaks a tiny postMessage protocol with the provider on the main
+ * thread (see `index.ts`):
+ *
+ *   main → worker : { type: 'prepare',  id, modelId, dtype?, device? }
+ *                   { type: 'generate', id, modelId, messages, options, dtype?, device? }
+ *   worker → main : { type: 'progress', id, status, file?, progress? }
+ *                   { type: 'prepare-error', id, message }
+ *                   { type: 'pipeline-ready', modelId }
+ *                   { type: 'gen-chunk', id, chunkType: 'text', delta }
+ *                   { type: 'gen-done', id }
+ *                   { type: 'gen-error', id, message }
+ *
+ * Deliberately generic: no vision, no low-level ORT session management, no
+ * model-family specifics — just the high-level `pipeline()` + `TextStreamer`.
+ */
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG"}

package/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@aparte/provider-transformers",
+  "version": "0.2.0-alpha.0",
+  "description": "Run LLMs 100% in the browser via Transformers.js (WebGPU/WASM) — a local, keyless AI provider for aparté. Streams tokens off the main thread in a Web Worker.",
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "@aparte-workspace/source": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "@huggingface/transformers": "^4.2.0",
+    "@aparte/core": "0.2.0-alpha.0"
+  },
+  "devDependencies": {
+    "@huggingface/transformers": "^4.2.0",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.4.0",
+    "vite": "^6.0.0",
+    "vite-plugin-dts": "^4.5.4",
+    "@aparte/core": "0.2.0-alpha.0"
+  },
+  "keywords": [
+    "ai",
+    "provider",
+    "transformers.js",
+    "webgpu",
+    "wasm",
+    "local",
+    "in-browser",
+    "llm"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/apartejs/aparte.git",
+    "directory": "packages/providers/ai/transformers"
+  },
+  "bugs": {
+    "url": "https://github.com/apartejs/aparte/issues"
+  },
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build && tsc -b --emitDeclarationOnly --force",
+    "preview": "vite preview",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage"
+  }
+}