@tryhamster/gerbil 1.0.0-rc.11 → 1.0.0-rc.13

package/dist/browser/index.js

@@ -1878,7 +1878,7 @@ function useVoiceInput(options = {}) {
 	const fullTranscriptRef = useRef("");
 	const transcribeResolveRef = useRef(null);
 	const transcribeRejectRef = useRef(null);
-	const resolveSTTModel = (modelId) => {
+	const resolveSTTModel$1 = (modelId) => {
 		return {
 			"whisper-tiny": "onnx-community/whisper-tiny",
 			"whisper-tiny.en": "onnx-community/whisper-tiny.en",
@@ -1969,7 +1969,7 @@ function useVoiceInput(options = {}) {
 		};
 		worker.postMessage({
 			type: "load",
-			payload: { model: resolveSTTModel(model) }
+			payload: { model: resolveSTTModel$1(model) }
 		});
 		return () => {
 			mountedRef.current = false;
@@ -2348,7 +2348,7 @@ function useVoiceChat(options = {}) {
 	const isListening = stage === "listening";
 	const isProcessing = stage === "transcribing" || stage === "thinking";
 	const isSpeaking = stage === "speaking";
-	const resolveSTTModel = (modelId) => {
+	const resolveSTTModel$1 = (modelId) => {
 		return {
 			"whisper-tiny": "onnx-community/whisper-tiny",
 			"whisper-tiny.en": "onnx-community/whisper-tiny.en",
@@ -2381,7 +2381,7 @@ function useVoiceChat(options = {}) {
 					sttWorker.onerror = (e) => reject(new Error(e.message));
 					sttWorker.postMessage({
 						type: "load",
-						payload: { model: resolveSTTModel(sttModel) }
+						payload: { model: resolveSTTModel$1(sttModel) }
 					});
 				});
 				if (cancelled || !mountedRef.current) {
@@ -2715,6 +2715,469 @@ function useVoiceChat(options = {}) {
 		load
 	};
 }
+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";
+  
+  // Configure environment
+  env.useBrowserCache = true;
+  env.allowLocalModels = false;
+  
+  let embedder = null;
+  let modelId = null;
+  
+  self.onmessage = async (e) => {
+    const { type, payload } = e.data;
+    
+    if (type === "load") {
+      try {
+        modelId = payload.model || "Xenova/all-MiniLM-L6-v2";
+        
+        embedder = await pipeline("feature-extraction", modelId, {
+          progress_callback: (progress) => {
+            self.postMessage({ type: "progress", payload: progress });
+          },
+        });
+        
+        // Warmup
+        try {
+          await embedder("hello", { pooling: "mean", normalize: true });
+        } catch (e) {
+          console.warn("Embedding warmup failed:", e);
+        }
+        
+        self.postMessage({ type: "ready" });
+      } catch (err) {
+        self.postMessage({ type: "error", payload: err.message || String(err) });
+      }
+    }
+    
+    if (type === "embed") {
+      try {
+        const { text, normalize } = payload;
+        const output = await embedder(text, {
+          pooling: "mean",
+          normalize: normalize !== false,
+        });
+        
+        const vector = Array.from(output.data);
+        self.postMessage({ type: "embedding", payload: { vector, text } });
+      } catch (err) {
+        self.postMessage({ type: "error", payload: err.message || String(err) });
+      }
+    }
+    
+    if (type === "embedBatch") {
+      try {
+        const { texts, normalize } = payload;
+        const results = [];
+        
+        for (const text of texts) {
+          const output = await embedder(text, {
+            pooling: "mean",
+            normalize: normalize !== false,
+          });
+          results.push({ vector: Array.from(output.data), text });
+        }
+        
+        self.postMessage({ type: "embeddings", payload: results });
+      } catch (err) {
+        self.postMessage({ type: "error", payload: err.message || String(err) });
+      }
+    }
+  };
+`;
+/** Create Embedding worker instance */
+function createEmbeddingWorker() {
+	const blob = new Blob([EMBEDDING_WORKER_CODE], { type: "application/javascript" });
+	const url = URL.createObjectURL(blob);
+	const worker = new Worker(url, { type: "module" });
+	URL.revokeObjectURL(url);
+	return worker;
+}
+/**
+* React hook for text embeddings in the browser
+*
+* @example
+* ```tsx
+* import { useEmbedding } from "@tryhamster/gerbil/browser";
+*
+* function App() {
+*   const { embed, similarity, search, isLoading, isReady } = useEmbedding();
+*
+*   if (isLoading) return <div>Loading embedding model...</div>;
+*
+*   const handleSearch = async () => {
+*     const results = await search("capital of France", [
+*       "Paris is beautiful",
+*       "London is in England",
+*       "Dogs are pets"
+*     ]);
+*     console.log(results); // [{ text: "Paris is beautiful", score: 0.89, index: 0 }, ...]
+*   };
+*
+*   return <button onClick={handleSearch}>Search</button>;
+* }
+* ```
+*/
+function useEmbedding(options = {}) {
+	const React = globalThis.React;
+	if (!React) throw new Error("useEmbedding requires React. Make sure React is available in the global scope.");
+	const { useState, useEffect, useRef, useCallback } = React;
+	const { model = "Xenova/all-MiniLM-L6-v2", normalize = true, autoLoad = false, onReady, onError } = options;
+	const [isLoading, setIsLoading] = useState(false);
+	const [isReady, setIsReady] = useState(false);
+	const [error, setError] = useState(null);
+	const [loadingProgress, setLoadingProgress] = useState(null);
+	const workerRef = useRef(null);
+	const loadRequestedRef = useRef(false);
+	const readyPromiseRef = useRef(null);
+	const readyResolveRef = useRef(null);
+	const cosineSimilarity = useCallback((a, b) => {
+		if (a.length !== b.length) throw new Error(`Vector dimensions must match: ${a.length} vs ${b.length}`);
+		let dotProduct = 0;
+		let normA = 0;
+		let normB = 0;
+		for (let i = 0; i < a.length; i++) {
+			dotProduct += a[i] * b[i];
+			normA += a[i] * a[i];
+			normB += b[i] * b[i];
+		}
+		const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+		if (magnitude === 0) return 0;
+		return dotProduct / magnitude;
+	}, []);
+	const load = useCallback(() => {
+		if (isReady && workerRef.current) return Promise.resolve();
+		if (loadRequestedRef.current && readyPromiseRef.current) return readyPromiseRef.current;
+		loadRequestedRef.current = true;
+		setIsLoading(true);
+		setLoadingProgress({
+			status: "loading",
+			message: "Loading embedding model..."
+		});
+		readyPromiseRef.current = new Promise((resolve) => {
+			readyResolveRef.current = resolve;
+		});
+		const worker = createEmbeddingWorker();
+		workerRef.current = worker;
+		worker.onmessage = (e) => {
+			const { type, payload } = e.data;
+			if (type === "progress") {
+				if (payload.status === "progress" && payload.file) setLoadingProgress({
+					status: "downloading",
+					message: `Downloading ${payload.file}`,
+					progress: Math.round(payload.loaded / payload.total * 100)
+				});
+			} else if (type === "ready") {
+				setIsLoading(false);
+				setIsReady(true);
+				setLoadingProgress({ status: "ready" });
+				readyResolveRef.current?.();
+				onReady?.();
+			} else if (type === "error") {
+				setIsLoading(false);
+				setError(payload);
+				onError?.(payload);
+			}
+		};
+		worker.postMessage({
+			type: "load",
+			payload: { model }
+		});
+		return readyPromiseRef.current;
+	}, [
+		model,
+		isReady,
+		onReady,
+		onError
+	]);
+	useEffect(() => {
+		if (autoLoad) load();
+		return () => {
+			if (workerRef.current) {
+				workerRef.current.terminate();
+				workerRef.current = null;
+			}
+		};
+	}, [autoLoad, load]);
+	const embed = useCallback(async (text) => {
+		await load();
+		return new Promise((resolve, reject) => {
+			const worker = workerRef.current;
+			if (!worker) {
+				reject(/* @__PURE__ */ new Error("Worker not initialized"));
+				return;
+			}
+			const handler = (e) => {
+				if (e.data.type === "embedding") {
+					worker.removeEventListener("message", handler);
+					resolve(e.data.payload.vector);
+				} else if (e.data.type === "error") {
+					worker.removeEventListener("message", handler);
+					reject(new Error(e.data.payload));
+				}
+			};
+			worker.addEventListener("message", handler);
+			worker.postMessage({
+				type: "embed",
+				payload: {
+					text,
+					normalize
+				}
+			});
+		});
+	}, [load, normalize]);
+	const embedBatch = useCallback(async (texts) => {
+		await load();
+		return new Promise((resolve, reject) => {
+			const worker = workerRef.current;
+			if (!worker) {
+				reject(/* @__PURE__ */ new Error("Worker not initialized"));
+				return;
+			}
+			const handler = (e) => {
+				if (e.data.type === "embeddings") {
+					worker.removeEventListener("message", handler);
+					resolve(e.data.payload);
+				} else if (e.data.type === "error") {
+					worker.removeEventListener("message", handler);
+					reject(new Error(e.data.payload));
+				}
+			};
+			worker.addEventListener("message", handler);
+			worker.postMessage({
+				type: "embedBatch",
+				payload: {
+					texts,
+					normalize
+				}
+			});
+		});
+	}, [load, normalize]);
+	return {
+		embed,
+		embedBatch,
+		similarity: useCallback(async (textA, textB) => {
+			const [embA, embB] = await Promise.all([embed(textA), embed(textB)]);
+			return cosineSimilarity(embA, embB);
+		}, [embed, cosineSimilarity]),
+		search: useCallback(async (query, corpus, topK) => {
+			const [queryEmb, corpusEmbs] = await Promise.all([embed(query), embedBatch(corpus)]);
+			const results = corpusEmbs.map((doc, index) => ({
+				text: doc.text,
+				score: cosineSimilarity(queryEmb, doc.vector),
+				index
+			}));
+			results.sort((a, b) => b.score - a.score);
+			return topK ? results.slice(0, topK) : results;
+		}, [
+			embed,
+			embedBatch,
+			cosineSimilarity
+		]),
+		findNearest: useCallback(async (embedding, candidates, topK) => {
+			const results = (await embedBatch(candidates)).map((doc, index) => ({
+				text: doc.text,
+				score: cosineSimilarity(embedding, doc.vector),
+				index
+			}));
+			results.sort((a, b) => b.score - a.score);
+			return topK ? results.slice(0, topK) : results;
+		}, [embedBatch, cosineSimilarity]),
+		cosineSimilarity,
+		load,
+		isLoading,
+		isReady,
+		loadingProgress,
+		error
+	};
+}
+/**
+* Preload a chat/LLM model (downloads to IndexedDB cache)
+*
+* Call this during app initialization to ensure the model is ready
+* when users need it.
+*
+* @example
+* ```ts
+* // In your app's initialization
+* import { preloadChatModel } from "@tryhamster/gerbil/browser";
+*
+* await preloadChatModel("qwen3-0.6b", {
+*   onProgress: (p) => console.log(p.status, p.progress),
+* });
+*
+* // Later, useChat will load instantly from cache
+* ```
+*/
+async function preloadChatModel(modelId, options = {}) {
+	const { onProgress } = options;
+	const worker = await createGerbilWorker({
+		modelId,
+		onProgress: (p) => {
+			if (p.status === "downloading") onProgress?.({
+				status: "downloading",
+				file: p.file,
+				progress: p.progress
+			});
+			else onProgress?.({
+				status: "loading",
+				message: p.status
+			});
+		}
+	});
+	onProgress?.({ status: "ready" });
+	worker.terminate();
+}
+/**
+* Preload an embedding model
+*
+* @example
+* ```ts
+* await preloadEmbeddingModel("Xenova/all-MiniLM-L6-v2");
+* ```
+*/
+async function preloadEmbeddingModel(modelId = "Xenova/all-MiniLM-L6-v2", options = {}) {
+	const { onProgress } = options;
+	return new Promise((resolve, reject) => {
+		const worker = createEmbeddingWorker();
+		worker.onmessage = (e) => {
+			const { type, payload } = e.data;
+			if (type === "progress") {
+				if (payload.status === "progress" && payload.file) onProgress?.({
+					status: "downloading",
+					file: payload.file,
+					progress: Math.round(payload.loaded / payload.total * 100)
+				});
+			} else if (type === "ready") {
+				onProgress?.({ status: "ready" });
+				worker.terminate();
+				resolve();
+			} else if (type === "error") {
+				onProgress?.({
+					status: "error",
+					message: payload
+				});
+				worker.terminate();
+				reject(new Error(payload));
+			}
+		};
+		onProgress?.({
+			status: "loading",
+			message: `Loading ${modelId}...`
+		});
+		worker.postMessage({
+			type: "load",
+			payload: { model: modelId }
+		});
+	});
+}
+/**
+* Preload a TTS model
+*
+* @example
+* ```ts
+* await preloadTTSModel("kokoro-82m");
+* ```
+*/
+async function preloadTTSModel(modelId = "kokoro-82m", options = {}) {
+	const { onProgress } = options;
+	const modelConfig = TTS_MODELS[modelId];
+	if (!modelConfig) throw new Error(`Unknown TTS model: ${modelId}`);
+	return new Promise((resolve, reject) => {
+		const worker = createTTSWorker();
+		worker.onmessage = (e) => {
+			const { type, payload } = e.data;
+			if (type === "progress") {
+				if (payload.status === "progress" && payload.file) onProgress?.({
+					status: "downloading",
+					file: payload.file,
+					progress: Math.round(payload.loaded / payload.total * 100)
+				});
+			} else if (type === "ready") {
+				onProgress?.({ status: "ready" });
+				worker.terminate();
+				resolve();
+			} else if (type === "error") {
+				onProgress?.({
+					status: "error",
+					message: payload
+				});
+				worker.terminate();
+				reject(new Error(payload));
+			}
+		};
+		onProgress?.({
+			status: "loading",
+			message: `Loading ${modelId}...`
+		});
+		worker.postMessage({
+			type: "load",
+			payload: {
+				modelId,
+				repo: modelConfig.repo,
+				voices: modelConfig.voices
+			}
+		});
+	});
+}
+/**
+* Preload an STT model
+*
+* @example
+* ```ts
+* await preloadSTTModel("whisper-tiny.en");
+* ```
+*/
+async function preloadSTTModel(modelId = "whisper-tiny.en", options = {}) {
+	const { onProgress } = options;
+	const resolved = resolveSTTModel(modelId);
+	return new Promise((resolve, reject) => {
+		const worker = createSTTWorker();
+		worker.onmessage = (e) => {
+			const { type, payload } = e.data;
+			if (type === "progress") {
+				if (payload.status === "progress" && payload.file) onProgress?.({
+					status: "downloading",
+					file: payload.file,
+					progress: Math.round(payload.loaded / payload.total * 100)
+				});
+			} else if (type === "ready") {
+				onProgress?.({ status: "ready" });
+				worker.terminate();
+				resolve();
+			} else if (type === "error") {
+				onProgress?.({
+					status: "error",
+					message: payload
+				});
+				worker.terminate();
+				reject(new Error(payload));
+			}
+		};
+		onProgress?.({
+			status: "loading",
+			message: `Loading ${modelId}...`
+		});
+		worker.postMessage({
+			type: "load",
+			payload: { modelId: resolved }
+		});
+	});
+}
+/** Helper to resolve STT model ID to repo */
+function resolveSTTModel(modelId) {
+	return {
+		"whisper-tiny": "onnx-community/whisper-tiny",
+		"whisper-tiny.en": "onnx-community/whisper-tiny.en",
+		"whisper-base": "onnx-community/whisper-base",
+		"whisper-base.en": "onnx-community/whisper-base.en",
+		"whisper-small": "onnx-community/whisper-small",
+		"whisper-small.en": "onnx-community/whisper-small.en",
+		"whisper-large-v3-turbo": "onnx-community/whisper-large-v3-turbo"
+	}[modelId] || modelId;
+}
 /**
 * Check if WebGPU is supported
 */
@@ -2745,9 +3208,13 @@ var browser_default = {
 	getWebGPUInfo,
 	createGerbilWorker,
 	playAudio,
-	createAudioPlayer
+	createAudioPlayer,
+	preloadChatModel,
+	preloadEmbeddingModel,
+	preloadTTSModel,
+	preloadSTTModel
 };
 
 //#endregion
-export { BUILTIN_MODELS, createAudioPlayer, createGerbilWorker, browser_default as default, getWebGPUInfo, isWebGPUSupported, playAudio, useChat, useCompletion, useSpeech, useVoiceChat, useVoiceInput };
+export { BUILTIN_MODELS, createAudioPlayer, createGerbilWorker, browser_default as default, getWebGPUInfo, isWebGPUSupported, playAudio, preloadChatModel, preloadEmbeddingModel, preloadSTTModel, preloadTTSModel, useChat, useCompletion, useEmbedding, useSpeech, useVoiceChat, useVoiceInput };
 //# sourceMappingURL=index.js.map