@tryhamster/gerbil 1.0.0-rc.19 → 1.0.0-rc.20

package/dist/browser/index.js

@@ -157,6 +157,39 @@ function resolveModel(modelId) {
 * gerbil.terminate();
 * ```
 */
+/** Generates inline JS code for CDN fallback import (used in worker strings) */
+const CDN_FALLBACK_CODE = `
+  const CDN_URLS = ${JSON.stringify([
+	"https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1",
+	"https://esm.sh/@huggingface/transformers@3.8.1",
+	"https://unpkg.com/@huggingface/transformers@3.8.1"
+])};
+  
+  let transformers = null;
+  let lastCdnError = null;
+  
+  for (const cdnUrl of CDN_URLS) {
+    try {
+      transformers = await import(cdnUrl);
+      break;
+    } catch (err) {
+      lastCdnError = err;
+      console.warn("CDN import failed (" + cdnUrl + "):", err.message);
+    }
+  }
+`;
+/**
+* Get a helpful error message when WebGPU is not supported.
+* Detects Safari/iOS for tailored guidance.
+*/
+function getWebGPUErrorMessage() {
+	if (typeof navigator === "undefined") return "WebGPU requires a browser environment.";
+	const ua = navigator.userAgent;
+	const isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
+	const isIOS = /iPhone|iPad|iPod/.test(ua);
+	if (isSafari || isIOS) return "WebGPU requires Safari 26+ (iOS 19+). Please update your device or use Chrome.";
+	return "WebGPU not supported. Use Chrome 113+, Edge 113+, or Safari 26+.";
+}
 /**
 * Create a Gerbil worker for streaming WebGPU inference
 *
@@ -167,17 +200,19 @@ async function createGerbilWorker(options = {}) {
 	const { modelId = "qwen3-0.6b", onProgress, onToken, onComplete, onError } = options;
 	const source = resolveModel(modelId);
 	return new Promise((resolve, reject) => {
-		const blob = new Blob([`
-      import {
-        AutoTokenizer,
-        AutoModelForCausalLM,
-        AutoProcessor,
-        AutoModelForImageTextToText,
-        RawImage,
-        TextStreamer,
-        InterruptableStoppingCriteria,
-        env,
-      } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
+		const workerCode = `
+      // Load transformers.js with CDN fallback
+      ${CDN_FALLBACK_CODE}
+      
+      if (!transformers) {
+        const errorMsg = "Failed to load ML library from all CDNs. Last error: " + 
+                         (lastCdnError?.message || "unknown") + 
+                         ". Check your network connection.";
+        self.postMessage({ status: "error", error: errorMsg });
+        throw new Error(errorMsg);
+      }
+      
+      const { AutoTokenizer, AutoModelForCausalLM, AutoProcessor, AutoModelForImageTextToText, RawImage, TextStreamer, InterruptableStoppingCriteria, env } = transformers;
 
       // Enable IndexedDB caching for browser (prevents re-downloading models)
       env.useBrowserCache = true;
@@ -207,7 +242,24 @@ async function createGerbilWorker(options = {}) {
             modelId.toLowerCase().includes("vlm");
 
           const dtype = options.dtype || "q4f16";
-          const device = options.device || "webgpu";
+          let device = options.device || "webgpu";
+          let usedFallback = false;
+
+          // Helper to load model with WASM fallback
+          async function loadWithFallback(loadFn, opts) {
+            try {
+              return await loadFn({ ...opts, device });
+            } catch (webgpuError) {
+              if (device === "webgpu") {
+                console.warn("WebGPU failed, falling back to WASM:", webgpuError.message);
+                self.postMessage({ status: "fallback", backend: "wasm", reason: webgpuError.message });
+                device = "wasm";
+                usedFallback = true;
+                return await loadFn({ ...opts, device: "wasm" });
+              }
+              throw webgpuError;
+            }
+          }
 
           if (this.isVision) {
             // Load vision model components
@@ -218,16 +270,17 @@ async function createGerbilWorker(options = {}) {
               });
             }
             if (!this.visionModel) {
-              this.visionModel = await AutoModelForImageTextToText.from_pretrained(modelId, {
-                device,
-                progress_callback: progressCallback,
-              });
+              this.visionModel = await loadWithFallback(
+                (opts) => AutoModelForImageTextToText.from_pretrained(modelId, opts),
+                { progress_callback: progressCallback }
+              );
             }
             return { 
               processor: this.processor, 
               model: this.visionModel, 
               tokenizer: this.processor.tokenizer,
-              isVision: true 
+              isVision: true,
+              usedFallback 
             };
           } else {
             // Load text-only model components
@@ -237,16 +290,16 @@ async function createGerbilWorker(options = {}) {
               });
             }
             if (!this.model) {
-              this.model = await AutoModelForCausalLM.from_pretrained(modelId, {
-                dtype,
-                device,
-                progress_callback: progressCallback,
-              });
+              this.model = await loadWithFallback(
+                (opts) => AutoModelForCausalLM.from_pretrained(modelId, opts),
+                { dtype, progress_callback: progressCallback }
+              );
             }
             return { 
               tokenizer: this.tokenizer, 
               model: this.model, 
-              isVision: false 
+              isVision: false,
+              usedFallback 
             };
           }
         }
@@ -527,7 +580,8 @@ async function createGerbilWorker(options = {}) {
       });
 
       self.postMessage({ status: "init" });
-    `], { type: "application/javascript" });
+    `;
+		const blob = new Blob([workerCode], { type: "application/javascript" });
 		const workerUrl = URL.createObjectURL(blob);
 		const worker = new Worker(workerUrl, { type: "module" });
 		let isReady = false;
@@ -580,7 +634,14 @@ async function createGerbilWorker(options = {}) {
 			}
 		};
 		worker.onerror = (e) => {
-			const error = e.message || "Worker error";
+			let error = e.message || "";
+			if (!error || error === "Script error.") {
+				const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+				const isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
+				const isIOS = /iPhone|iPad|iPod/.test(ua);
+				if (isSafari || isIOS) error = "Worker failed to initialize. Safari 26+ (iOS 19+) is required for WebGPU. Try updating your device or using Chrome.";
+				else error = "Worker failed to initialize. This may be due to browser restrictions or WebGPU not being available. Try Chrome 113+ or Edge 113+.";
+			}
 			onError?.(error);
 			reject(new Error(error));
 		};
@@ -681,9 +742,10 @@ function useChat(options = {}) {
 	useEffect(() => {
 		if (!shouldLoad) return;
 		if (!isWebGPUSupported()) {
-			setError("WebGPU not supported. Use Chrome/Edge 113+.");
+			const gpuError = getWebGPUErrorMessage();
+			setError(gpuError);
 			setIsLoading(false);
-			onError?.("WebGPU not supported");
+			onError?.(gpuError);
 			return;
 		}
 		mountedRef.current = true;
@@ -729,6 +791,27 @@ function useChat(options = {}) {
 			workerRef.current?.terminate();
 		};
 	}, [model, shouldLoad]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		const handleVisibility = () => {
+			if (document.hidden && isGenerating && workerRef.current) {
+				workerRef.current.interrupt();
+				setIsGenerating(false);
+				if (currentResponse) {
+					setMessages((msgs) => {
+						if (msgs.at(-1)?.role === "assistant") return msgs.map((m, i) => i === msgs.length - 1 ? {
+							...m,
+							content: currentResponse + " [stopped - tab hidden]"
+						} : m);
+						return msgs;
+					});
+					setCurrentResponse("");
+				}
+			}
+		};
+		document.addEventListener("visibilitychange", handleVisibility);
+		return () => document.removeEventListener("visibilitychange", handleVisibility);
+	}, [isGenerating, currentResponse]);
 	useEffect(() => {
 		if (!isGenerating && currentResponse) {
 			setMessages((msgs) => {
@@ -928,9 +1011,10 @@ function useCompletion(options = {}) {
 	useEffect(() => {
 		if (!shouldLoad) return;
 		if (!isWebGPUSupported()) {
-			setError("WebGPU not supported. Use Chrome/Edge 113+.");
+			const gpuError = getWebGPUErrorMessage();
+			setError(gpuError);
 			setIsLoading(false);
-			onError?.("WebGPU not supported");
+			onError?.(gpuError);
 			return;
 		}
 		mountedRef.current = true;
@@ -978,6 +1062,17 @@ function useCompletion(options = {}) {
 			workerRef.current?.terminate();
 		};
 	}, [model, shouldLoad]);
+	useEffect(() => {
+		if (typeof document === "undefined") return;
+		const handleVisibility = () => {
+			if (document.hidden && isGenerating && workerRef.current) {
+				workerRef.current.interrupt();
+				setIsGenerating(false);
+			}
+		};
+		document.addEventListener("visibilitychange", handleVisibility);
+		return () => document.removeEventListener("visibilitychange", handleVisibility);
+	}, [isGenerating]);
 	const complete = useCallback((prompt, completeOptions) => {
 		return new Promise((resolve, reject) => {
 			setCompletion("");
@@ -1292,7 +1387,15 @@ const TTS_MODELS = {
 };
 const TTS_WORKER_CODE = `
   // TTS Worker - runs in separate thread, loads from CDN
-  import { pipeline, env } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
+  ${CDN_FALLBACK_CODE}
+  
+  if (!transformers) {
+    const errorMsg = "Failed to load TTS library from all CDNs: " + (lastCdnError?.message || "unknown");
+    self.postMessage({ type: "error", payload: errorMsg });
+    throw new Error(errorMsg);
+  }
+  
+  const { pipeline, env } = transformers;
   
   // Configure environment
   env.useBrowserCache = true;
@@ -1312,13 +1415,25 @@ const TTS_WORKER_CODE = `
         modelType = modelId === "supertonic-66m" ? "supertonic" : "kokoro";
         
         if (modelType === "supertonic") {
-          // Load Supertonic using transformers.js pipeline
-          ttsInstance = await pipeline("text-to-speech", repo, {
-            device: "webgpu",
-            progress_callback: (progress) => {
-              self.postMessage({ type: "progress", payload: progress });
-            },
-          });
+          // Load Supertonic using transformers.js pipeline with WASM fallback
+          let device = "webgpu";
+          try {
+            ttsInstance = await pipeline("text-to-speech", repo, {
+              device,
+              progress_callback: (progress) => {
+                self.postMessage({ type: "progress", payload: progress });
+              },
+            });
+          } catch (webgpuError) {
+            console.warn("WebGPU failed for TTS, falling back to WASM:", webgpuError.message);
+            self.postMessage({ type: "fallback", payload: { backend: "wasm", reason: webgpuError.message } });
+            ttsInstance = await pipeline("text-to-speech", repo, {
+              device: "wasm",
+              progress_callback: (progress) => {
+                self.postMessage({ type: "progress", payload: progress });
+              },
+            });
+          }
           
           // Load voice embeddings
           for (const voice of voices) {
@@ -1528,7 +1643,8 @@ function useSpeech(options = {}) {
 		};
 		worker.onerror = (err) => {
 			if (!mountedRef.current) return;
-			const errorMsg = err.message || "Worker error";
+			let errorMsg = err.message || "";
+			if (!errorMsg || errorMsg === "Script error.") errorMsg = getWebGPUErrorMessage();
 			setError(errorMsg);
 			setIsLoading(false);
 			setLoadingProgress({
@@ -1758,7 +1874,15 @@ function createAudioPlayer(sampleRate = 24e3) {
 }
 const STT_WORKER_CODE = `
   // STT Worker - runs in separate thread, loads from CDN
-  import { pipeline, env } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
+  ${CDN_FALLBACK_CODE}
+  
+  if (!transformers) {
+    const errorMsg = "Failed to load STT library from all CDNs: " + (lastCdnError?.message || "unknown");
+    self.postMessage({ type: "error", payload: errorMsg });
+    throw new Error(errorMsg);
+  }
+  
+  const { pipeline, env } = transformers;
   
   // Configure environment
   env.useBrowserCache = true;
@@ -1773,13 +1897,25 @@ const STT_WORKER_CODE = `
       try {
         const { model } = payload;
         
-        // Load Whisper model
-        sttPipeline = await pipeline("automatic-speech-recognition", model, {
-          device: "webgpu",
-          progress_callback: (progress) => {
-            self.postMessage({ type: "progress", payload: progress });
-          },
-        });
+        // Load Whisper model with WASM fallback
+        let device = "webgpu";
+        try {
+          sttPipeline = await pipeline("automatic-speech-recognition", model, {
+            device,
+            progress_callback: (progress) => {
+              self.postMessage({ type: "progress", payload: progress });
+            },
+          });
+        } catch (webgpuError) {
+          console.warn("WebGPU failed for STT, falling back to WASM:", webgpuError.message);
+          self.postMessage({ type: "fallback", payload: { backend: "wasm", reason: webgpuError.message } });
+          sttPipeline = await pipeline("automatic-speech-recognition", model, {
+            device: "wasm",
+            progress_callback: (progress) => {
+              self.postMessage({ type: "progress", payload: progress });
+            },
+          });
+        }
         
         self.postMessage({ type: "ready" });
       } catch (err) {
@@ -1954,7 +2090,8 @@ function useVoiceInput(options = {}) {
 		};
 		worker.onerror = (err) => {
 			if (!mountedRef.current) return;
-			const errMsg = err.message || "Worker error";
+			let errMsg = err.message || "";
+			if (!errMsg || errMsg === "Script error.") errMsg = getWebGPUErrorMessage();
 			setError(errMsg);
 			setIsLoading(false);
 			setLoadingProgress({
@@ -2717,7 +2854,15 @@ function useVoiceChat(options = {}) {
 }
 const EMBEDDING_WORKER_CODE = `
   // Embedding Worker - runs in separate thread, loads from CDN
-  import { pipeline, env } from "https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1";
+  ${CDN_FALLBACK_CODE}
+  
+  if (!transformers) {
+    const errorMsg = "Failed to load embedding library from all CDNs: " + (lastCdnError?.message || "unknown");
+    self.postMessage({ type: "error", payload: errorMsg });
+    throw new Error(errorMsg);
+  }
+  
+  const { pipeline, env } = transformers;
   
   // Configure environment
   env.useBrowserCache = true;
@@ -2902,7 +3047,8 @@ function useEmbedding(options = {}) {
 		});
 		worker.onerror = (err) => {
 			setIsLoading(false);
-			const errMsg = err.message || "Worker error";
+			let errMsg = err.message || "";
+			if (!errMsg || errMsg === "Script error.") errMsg = getWebGPUErrorMessage();
 			setError(errMsg);
 			setLoadingProgress({
 				status: "error",
@@ -3223,33 +3369,258 @@ function resolveSTTModel(modelId) {
 	}[modelId] || modelId;
 }
 /**
-* Check if WebGPU is supported
+* Check if WebGPU API exists in browser (sync check)
+* Note: This only checks if the API exists, not if it actually works.
+* Use checkWebGPUReady() for a full verification.
 */
 function isWebGPUSupported() {
 	if (typeof navigator === "undefined") return false;
 	return "gpu" in navigator;
 }
 /**
+* Async check if WebGPU is actually ready to use.
+* This requests an adapter to verify WebGPU truly works.
+* Returns an object with supported status and reason for failure.
+*/
+async function checkWebGPUReady() {
+	if (typeof navigator === "undefined") return {
+		supported: false,
+		reason: "Not in browser environment"
+	};
+	if (!("gpu" in navigator)) {
+		const ua = navigator.userAgent;
+		const isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
+		const isIOS = /iPhone|iPad|iPod/.test(ua);
+		if (isSafari || isIOS) return {
+			supported: false,
+			reason: "WebGPU requires Safari 26+ (iOS 19+). Update your device or use Chrome/Edge."
+		};
+		return {
+			supported: false,
+			reason: "WebGPU not available. Use Chrome 113+, Edge 113+, or Safari 26+."
+		};
+	}
+	try {
+		const adapter = await navigator.gpu.requestAdapter();
+		if (!adapter) return {
+			supported: false,
+			reason: "No GPU adapter found. Your device may not have compatible graphics hardware."
+		};
+		return {
+			supported: true,
+			adapter: await adapter.requestAdapterInfo()
+		};
+	} catch (e) {
+		return {
+			supported: false,
+			reason: e?.message || "Failed to initialize WebGPU adapter"
+		};
+	}
+}
+/**
 * Get WebGPU adapter info
 */
 async function getWebGPUInfo() {
-	if (!isWebGPUSupported()) return { supported: false };
+	const result = await checkWebGPUReady();
+	if (!result.supported) return {
+		supported: false,
+		reason: result.reason
+	};
+	return {
+		supported: true,
+		adapter: result.adapter?.vendor,
+		device: result.adapter?.device
+	};
+}
+/**
+* Minimum WebGPU buffer size required for different model sizes (in bytes)
+*/
+const MODEL_BUFFER_REQUIREMENTS = {
+	"smollm2-135m": 2e8,
+	"smollm2-360m": 45e7,
+	"qwen3-0.6b": 7e8,
+	"qwen3-1.7b": 2e9,
+	"whisper-tiny": 15e7,
+	"kokoro-82m": 4e8
+};
+/**
+* Check if WebGPU has sufficient capabilities for a specific model.
+* Returns detailed limits and whether the model can run.
+*/
+async function checkWebGPUCapabilities(modelId) {
+	if (!("gpu" in navigator)) return {
+		supported: false,
+		reason: "WebGPU not available"
+	};
 	try {
 		const adapter = await navigator.gpu.requestAdapter();
-		if (!adapter) return { supported: false };
-		const info = await adapter.requestAdapterInfo();
-		return {
+		if (!adapter) return {
+			supported: false,
+			reason: "No GPU adapter available"
+		};
+		const limits = adapter.limits;
+		const result = {
 			supported: true,
-			adapter: info.vendor,
-			device: info.device
+			limits: {
+				maxBufferSize: limits.maxBufferSize,
+				maxStorageBufferBindingSize: limits.maxStorageBufferBindingSize,
+				maxComputeWorkgroupStorageSize: limits.maxComputeWorkgroupStorageSize
+			},
+			canRunModel: true,
+			modelRequirement: void 0
+		};
+		if (modelId) {
+			const normalizedId = modelId.toLowerCase().replace(/[^a-z0-9]/g, "-");
+			const requirement = Object.entries(MODEL_BUFFER_REQUIREMENTS).find(([key]) => normalizedId.includes(key.toLowerCase().replace(/[^a-z0-9]/g, "-")))?.[1];
+			if (requirement) {
+				result.modelRequirement = requirement;
+				result.canRunModel = limits.maxStorageBufferBindingSize >= requirement;
+				if (!result.canRunModel) return {
+					...result,
+					reason: `GPU buffer size (${Math.round(limits.maxStorageBufferBindingSize / 1e6)}MB) is smaller than model requirement (${Math.round(requirement / 1e6)}MB). Try a smaller model like smollm2-135m.`
+				};
+			}
+		}
+		return result;
+	} catch (e) {
+		return {
+			supported: false,
+			reason: e?.message || "Failed to check WebGPU capabilities"
 		};
+	}
+}
+/**
+* Get browser compatibility diagnostics for debugging.
+* Useful for understanding why Gerbil might not work on a device.
+*/
+async function getBrowserDiagnostics() {
+	const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+	const isSafari = /Safari/.test(ua) && !/Chrome/.test(ua);
+	const isIOS = /iPhone|iPad|iPod/.test(ua);
+	let browser = "Unknown";
+	if (/Chrome\/(\d+)/.test(ua)) browser = `Chrome ${RegExp.$1}`;
+	else if (/Firefox\/(\d+)/.test(ua)) browser = `Firefox ${RegExp.$1}`;
+	else if (/Version\/(\d+).*Safari/.test(ua)) browser = `Safari ${RegExp.$1}`;
+	else if (/Edg\/(\d+)/.test(ua)) browser = `Edge ${RegExp.$1}`;
+	const webgpuResult = await checkWebGPUReady();
+	const webgpu = {
+		supported: webgpuResult.supported,
+		reason: webgpuResult.reason,
+		adapter: webgpuResult.adapter?.vendor
+	};
+	let moduleWorkers = false;
+	try {
+		const blob = new Blob(["self.postMessage('ok')"], { type: "application/javascript" });
+		const url = URL.createObjectURL(blob);
+		const worker = new Worker(url, { type: "module" });
+		await new Promise((resolve, reject) => {
+			worker.onmessage = () => resolve();
+			worker.onerror = () => reject();
+			setTimeout(() => reject(), 1e3);
+		});
+		worker.terminate();
+		URL.revokeObjectURL(url);
+		moduleWorkers = true;
 	} catch {
-		return { supported: false };
+		moduleWorkers = false;
+	}
+	let indexedDB = false;
+	try {
+		indexedDB = typeof window !== "undefined" && "indexedDB" in window;
+	} catch {
+		indexedDB = false;
+	}
+	return {
+		browser,
+		isSafari,
+		isIOS,
+		webgpu,
+		moduleWorkers,
+		indexedDB
+	};
+}
+/**
+* Get recommended models based on device memory and capabilities.
+* Helps prevent OOM crashes on low-memory mobile devices.
+*/
+function getRecommendedModels() {
+	const ua = typeof navigator !== "undefined" ? navigator.userAgent : "";
+	const deviceMemory = typeof navigator !== "undefined" ? navigator.deviceMemory : null;
+	const isMobile = /iPhone|iPad|iPod|Android|Mobile/.test(ua);
+	const availableMB = (deviceMemory ? isMobile ? deviceMemory * .4 : deviceMemory * .6 : 4) * 1024;
+	let chat;
+	let reason;
+	if (availableMB < 500) {
+		chat = "smollm2-135m";
+		reason = "Very low memory device - using smallest model";
+	} else if (availableMB < 1e3 || isMobile && availableMB < 1500) {
+		chat = "smollm2-360m";
+		reason = isMobile ? "Mobile device - using smaller model to prevent crashes" : "Low memory - using smaller model";
+	} else if (availableMB < 2e3) {
+		chat = "qwen3-0.6b";
+		reason = "Standard model for moderate memory";
+	} else {
+		chat = "qwen3-1.7b";
+		reason = "High memory available - using larger model for better quality";
+	}
+	return {
+		chat,
+		tts: "kokoro-82m",
+		stt: "whisper-tiny.en",
+		embedding: "all-MiniLM-L6-v2",
+		reason,
+		deviceMemory,
+		isMobile
+	};
+}
+/**
+* Check if there's enough storage quota for a model download.
+* Returns estimated available space and whether download should proceed.
+*/
+async function checkStorageQuota(requiredMB = 500) {
+	if (typeof navigator === "undefined" || !navigator.storage?.estimate) return {
+		ok: true,
+		availableMB: -1,
+		usedMB: -1,
+		quotaMB: -1,
+		message: "Storage API not available"
+	};
+	try {
+		const { quota, usage } = await navigator.storage.estimate();
+		const quotaMB = Math.round((quota || 0) / 1e6);
+		const usedMB = Math.round((usage || 0) / 1e6);
+		const availableMB = quotaMB - usedMB;
+		if (availableMB < requiredMB) return {
+			ok: false,
+			availableMB,
+			usedMB,
+			quotaMB,
+			message: `Need ${requiredMB}MB but only ${availableMB}MB available. Clear browser data or free up space.`
+		};
+		return {
+			ok: true,
+			availableMB,
+			usedMB,
+			quotaMB
+		};
+	} catch (e) {
+		return {
+			ok: true,
+			availableMB: -1,
+			usedMB: -1,
+			quotaMB: -1,
+			message: `Storage check failed: ${e.message}`
+		};
 	}
 }
 var browser_default = {
 	isWebGPUSupported,
+	checkWebGPUReady,
+	checkWebGPUCapabilities,
 	getWebGPUInfo,
+	getBrowserDiagnostics,
+	getRecommendedModels,
+	checkStorageQuota,
 	createGerbilWorker,
 	playAudio,
 	createAudioPlayer,
@@ -3260,5 +3631,5 @@ var browser_default = {
 };
 
 //#endregion
-export { BUILTIN_MODELS, createAudioPlayer, createGerbilWorker, browser_default as default, getWebGPUInfo, isWebGPUSupported, playAudio, preloadChatModel, preloadEmbeddingModel, preloadSTTModel, preloadTTSModel, useChat, useCompletion, useEmbedding, useSpeech, useVoiceChat, useVoiceInput };
+export { BUILTIN_MODELS, checkStorageQuota, checkWebGPUCapabilities, checkWebGPUReady, createAudioPlayer, createGerbilWorker, browser_default as default, getBrowserDiagnostics, getRecommendedModels, getWebGPUInfo, isWebGPUSupported, playAudio, preloadChatModel, preloadEmbeddingModel, preloadSTTModel, preloadTTSModel, useChat, useCompletion, useEmbedding, useSpeech, useVoiceChat, useVoiceInput };
 //# sourceMappingURL=index.js.map