@tryhamster/gerbil 1.0.0-rc.0 → 1.0.0-rc.2

package/dist/gerbil-yoSpRHgv.mjs

@@ -0,0 +1,1463 @@
+import { i as getModelConfig, n as createExternalModelConfig, o as resolveModel, r as fetchModelContextLength, t as BUILTIN_MODELS } from "./models-BAtL8qsA.mjs";
+import { n as zodToJsonSchema, t as extractJson } from "./utils-CkB4Roi6.mjs";
+import { AutoModelForCausalLM, AutoModelForImageTextToText, AutoProcessor, AutoTokenizer, RawImage, TextStreamer, env, pipeline } from "@huggingface/transformers";
+
+//#region src/core/cache.ts
+/**
+* Generate a deterministic cache key from prompt and options.
+* Key includes all parameters that affect the output.
+*/
+function generateCacheKey(prompt, modelId, options) {
+	const keyParts = [
+		prompt,
+		modelId,
+		options.maxTokens ?? 256,
+		options.temperature ?? .7,
+		options.topP ?? .9,
+		options.topK ?? 50,
+		options.system ?? "",
+		options.thinking ?? false
+	];
+	const str = JSON.stringify(keyParts);
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return `gerbil:${hash.toString(16)}`;
+}
+/**
+* LRU cache with TTL expiration for inference responses.
+*/
+var ResponseCache = class {
+	cache = /* @__PURE__ */ new Map();
+	maxSize;
+	defaultTtl;
+	hits = 0;
+	misses = 0;
+	/**
+	* Create a new response cache.
+	* @param maxSize Maximum number of entries (default: 100)
+	* @param defaultTtl Default TTL in ms (default: 5 minutes)
+	*/
+	constructor(maxSize = 100, defaultTtl = 300 * 1e3) {
+		this.maxSize = maxSize;
+		this.defaultTtl = defaultTtl;
+	}
+	/**
+	* Get a cached response if it exists and hasn't expired.
+	*/
+	get(key) {
+		const entry = this.cache.get(key);
+		if (!entry) {
+			this.misses++;
+			return null;
+		}
+		if (Date.now() - entry.createdAt > entry.ttl) {
+			this.cache.delete(key);
+			this.misses++;
+			return null;
+		}
+		this.cache.delete(key);
+		this.cache.set(key, entry);
+		this.hits++;
+		return {
+			...entry.result,
+			cached: true
+		};
+	}
+	/**
+	* Store a response in the cache.
+	*/
+	set(key, result, ttl) {
+		while (this.cache.size >= this.maxSize) {
+			const firstKey = this.cache.keys().next().value;
+			if (firstKey) this.cache.delete(firstKey);
+		}
+		this.cache.set(key, {
+			result,
+			createdAt: Date.now(),
+			ttl: ttl ?? this.defaultTtl
+		});
+	}
+	/**
+	* Check if a key exists and is not expired.
+	*/
+	has(key) {
+		const entry = this.cache.get(key);
+		if (!entry) return false;
+		if (Date.now() - entry.createdAt > entry.ttl) {
+			this.cache.delete(key);
+			return false;
+		}
+		return true;
+	}
+	/**
+	* Remove a specific key from the cache.
+	*/
+	delete(key) {
+		return this.cache.delete(key);
+	}
+	/**
+	* Clear all entries from the cache.
+	*/
+	clear() {
+		this.cache.clear();
+		this.hits = 0;
+		this.misses = 0;
+	}
+	/**
+	* Remove all expired entries.
+	*/
+	prune() {
+		const now = Date.now();
+		let pruned = 0;
+		for (const [key, entry] of this.cache) if (now - entry.createdAt > entry.ttl) {
+			this.cache.delete(key);
+			pruned++;
+		}
+		return pruned;
+	}
+	/**
+	* Get cache statistics.
+	*/
+	getStats() {
+		return {
+			hits: this.hits,
+			misses: this.misses,
+			size: this.cache.size,
+			maxSize: this.maxSize
+		};
+	}
+	/**
+	* Get hit rate as a percentage.
+	*/
+	getHitRate() {
+		const total = this.hits + this.misses;
+		if (total === 0) return 0;
+		return this.hits / total * 100;
+	}
+};
+let globalCache = null;
+/**
+* Get the global response cache instance.
+* Creates one if it doesn't exist.
+*/
+function getGlobalCache() {
+	if (!globalCache) globalCache = new ResponseCache();
+	return globalCache;
+}
+/**
+* Configure the global cache with custom settings.
+*/
+function configureGlobalCache(maxSize, defaultTtl) {
+	globalCache = new ResponseCache(maxSize, defaultTtl);
+	return globalCache;
+}
+/**
+* Clear and reset the global cache.
+*/
+function clearGlobalCache() {
+	if (globalCache) globalCache.clear();
+}
+
+//#endregion
+//#region src/core/gerbil.ts
+/**
+* Gerbil - Local GPU-accelerated LLM inference
+*/
+const pipeline$1 = pipeline;
+function suppressNoisyWarnings(fn) {
+	const originalWarn = console.warn;
+	console.warn = (...args) => {
+		const msg = args[0]?.toString?.() || "";
+		if (msg.includes("content-length") || msg.includes("Unable to determine")) return;
+		originalWarn.apply(console, args);
+	};
+	return fn().finally(() => {
+		console.warn = originalWarn;
+	});
+}
+const KOKORO_VOICES_DEFAULT = [
+	{
+		id: "af_bella",
+		name: "Bella",
+		gender: "female",
+		language: "en-us",
+		description: "American female, warm and friendly"
+	},
+	{
+		id: "af_sarah",
+		name: "Sarah",
+		gender: "female",
+		language: "en-us",
+		description: "American female, clear and professional"
+	},
+	{
+		id: "af_nicole",
+		name: "Nicole",
+		gender: "female",
+		language: "en-us",
+		description: "American female, soft and gentle"
+	},
+	{
+		id: "af_sky",
+		name: "Sky",
+		gender: "female",
+		language: "en-us",
+		description: "American female, young and energetic"
+	},
+	{
+		id: "am_adam",
+		name: "Adam",
+		gender: "male",
+		language: "en-us",
+		description: "American male, deep and confident"
+	},
+	{
+		id: "am_michael",
+		name: "Michael",
+		gender: "male",
+		language: "en-us",
+		description: "American male, warm and friendly"
+	},
+	{
+		id: "bf_emma",
+		name: "Emma",
+		gender: "female",
+		language: "en-gb",
+		description: "British female, elegant and clear"
+	},
+	{
+		id: "bf_isabella",
+		name: "Isabella",
+		gender: "female",
+		language: "en-gb",
+		description: "British female, sophisticated"
+	},
+	{
+		id: "bm_george",
+		name: "George",
+		gender: "male",
+		language: "en-gb",
+		description: "British male, distinguished"
+	},
+	{
+		id: "bm_lewis",
+		name: "Lewis",
+		gender: "male",
+		language: "en-gb",
+		description: "British male, friendly and warm"
+	}
+];
+const isBrowser = typeof window !== "undefined";
+env.allowLocalModels = !isBrowser;
+env.useBrowserCache = isBrowser;
+let webgpuInitialized = false;
+let webgpuAvailable = false;
+/**
+* Initialize WebGPU for Node.js environments
+* Called automatically before model loading
+*/
+async function initNodeWebGPU() {
+	if (webgpuInitialized) return webgpuAvailable;
+	webgpuInitialized = true;
+	if (typeof window !== "undefined") {
+		webgpuAvailable = "gpu" in navigator;
+		return webgpuAvailable;
+	}
+	try {
+		const { create, globals } = await new Function("specifier", "return import(specifier)")("webgpu");
+		Object.assign(globalThis, globals);
+		if (!globalThis.navigator) globalThis.navigator = {};
+		globalThis.navigator.gpu = create([]);
+		webgpuAvailable = true;
+	} catch {
+		webgpuAvailable = false;
+	}
+	return webgpuAvailable;
+}
+var Gerbil = class {
+	generator = null;
+	tokenizer = null;
+	model = null;
+	embedder = null;
+	currentModel = null;
+	modelConfig = null;
+	config;
+	stats;
+	useDirect = false;
+	chromeBackend = null;
+	_deviceMode = "cpu";
+	processor = null;
+	visionModel = null;
+	isVisionModel = false;
+	constructor(config = {}) {
+		this.config = config;
+		this.stats = {
+			prompts: 0,
+			tokensIn: 0,
+			tokensOut: 0,
+			avgSpeed: 0,
+			totalTime: 0,
+			cacheHits: 0,
+			cacheMisses: 0
+		};
+	}
+	static listModels() {
+		return Object.values(BUILTIN_MODELS);
+	}
+	static getModel(modelId) {
+		return BUILTIN_MODELS[modelId];
+	}
+	/**
+	* Load a model
+	*
+	* @example
+	* ```ts
+	* // Built-in model
+	* await g.loadModel("qwen3-0.6b");
+	*
+	* // HuggingFace model
+	* await g.loadModel("hf:microsoft/Phi-3-mini");
+	*
+	* // Local model
+	* await g.loadModel("file:./models/my-model");
+	*
+	* // Vision model
+	* await g.loadModel("ministral-3b");
+	* ```
+	*/
+	async loadModel(modelId = "qwen3-0.6b", options = {}) {
+		if (this.isLoaded()) await this.dispose();
+		await initNodeWebGPU();
+		const source = resolveModel(modelId);
+		const { onProgress, device = "auto", dtype: userDtype } = options;
+		let config = getModelConfig(modelId);
+		if (!config) {
+			const contextLength = await fetchModelContextLength(source.path).catch(() => null);
+			config = createExternalModelConfig(modelId, source.path, contextLength || void 0);
+		}
+		if (config.supportsVision) return this.loadVisionModel(modelId, source.path, config, options);
+		onProgress?.({ status: `Loading ${modelId}...` });
+		const isBrowser$1 = typeof window !== "undefined";
+		const fallbackDevice = isBrowser$1 ? "wasm" : "cpu";
+		let tfDevice = fallbackDevice;
+		if (device === "webgpu" || device === "gpu" || device === "auto") tfDevice = "webgpu";
+		const dtype = userDtype ?? (tfDevice === "webgpu" ? "q4f16" : "q4");
+		let isLoading = true;
+		let lastFile = "";
+		let lastPct = -1;
+		const progressCallback = (progress) => {
+			if (!isLoading) return;
+			if (progress.status === "progress" && progress.file) {
+				const pct = Math.round(progress.progress || 0);
+				if (progress.file !== lastFile || pct >= lastPct + 5) {
+					lastFile = progress.file;
+					lastPct = pct;
+					onProgress?.({
+						status: `Downloading ${progress.file}`,
+						progress: pct,
+						file: progress.file
+					});
+				}
+			}
+		};
+		try {
+			if (isBrowser$1 && tfDevice === "webgpu") {
+				onProgress?.({ status: "Loading tokenizer..." });
+				this.tokenizer = await suppressNoisyWarnings(() => AutoTokenizer.from_pretrained(source.path, { progress_callback: progressCallback }));
+				onProgress?.({ status: "Loading model..." });
+				this.model = await suppressNoisyWarnings(() => AutoModelForCausalLM.from_pretrained(source.path, {
+					dtype,
+					device: tfDevice,
+					progress_callback: progressCallback
+				}));
+				this.useDirect = true;
+				this._deviceMode = "webgpu";
+				this.isVisionModel = false;
+				isLoading = false;
+				this.currentModel = modelId;
+				this.modelConfig = config;
+				onProgress?.({ status: "Ready (WebGPU)!" });
+			} else if (!isBrowser$1 && tfDevice === "webgpu") {
+				onProgress?.({ status: "Starting Chrome WebGPU backend..." });
+				const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+				this.chromeBackend = await ChromeGPUBackend.create({
+					modelId: source.path,
+					contextLength: config.contextLength,
+					onProgress
+				});
+				this.useDirect = false;
+				this._deviceMode = "webgpu";
+				this.isVisionModel = false;
+				isLoading = false;
+				this.currentModel = modelId;
+				this.modelConfig = config;
+			} else {
+				const pipelineOptions = {
+					dtype,
+					device: tfDevice,
+					progress_callback: progressCallback
+				};
+				this.generator = await suppressNoisyWarnings(() => pipeline$1("text-generation", source.path, pipelineOptions));
+				this.useDirect = false;
+				this._deviceMode = tfDevice;
+				this.isVisionModel = false;
+				isLoading = false;
+				this.currentModel = modelId;
+				this.modelConfig = config;
+				onProgress?.({ status: `Ready (${tfDevice.toUpperCase()})!` });
+			}
+		} catch (err) {
+			if (tfDevice !== fallbackDevice) {
+				onProgress?.({ status: `Using ${fallbackDevice.toUpperCase()}...` });
+				if (this.chromeBackend) {
+					await this.chromeBackend.dispose();
+					this.chromeBackend = null;
+				}
+				this.generator = await suppressNoisyWarnings(() => pipeline$1("text-generation", source.path, {
+					dtype: "q4",
+					device: fallbackDevice,
+					progress_callback: progressCallback
+				}));
+				this.useDirect = false;
+				this._deviceMode = fallbackDevice;
+				this.isVisionModel = false;
+				isLoading = false;
+				this.currentModel = modelId;
+				this.modelConfig = config;
+				onProgress?.({ status: `Ready (${fallbackDevice.toUpperCase()})!` });
+			} else throw err;
+		}
+	}
+	/**
+	* Load a vision model (VLM)
+	* Uses AutoProcessor + AutoModelForImageTextToText instead of tokenizer + causal LM
+	*/
+	async loadVisionModel(modelId, repoPath, config, options = {}) {
+		const { onProgress, device = "auto" } = options;
+		onProgress?.({ status: `Loading ${modelId} (vision model)...` });
+		const isBrowser$1 = typeof window !== "undefined";
+		const fallbackDevice = isBrowser$1 ? "wasm" : "cpu";
+		let tfDevice = fallbackDevice;
+		if (device === "webgpu" || device === "gpu" || device === "auto") tfDevice = "webgpu";
+		if (!isBrowser$1 && tfDevice === "webgpu") {
+			onProgress?.({ status: "Starting Chrome WebGPU backend (vision)..." });
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			this.chromeBackend = await ChromeGPUBackend.create({
+				modelId: repoPath,
+				contextLength: config.contextLength,
+				isVision: true,
+				onProgress
+			});
+			this.useDirect = false;
+			this._deviceMode = "webgpu";
+			this.isVisionModel = true;
+			this.currentModel = modelId;
+			this.modelConfig = config;
+			return;
+		}
+		let lastFile = "";
+		let lastPct = -1;
+		const progressCallback = (progress) => {
+			if (progress.status === "progress" && progress.file) {
+				const pct = Math.round(progress.progress || 0);
+				if (progress.file !== lastFile || pct >= lastPct + 5) {
+					lastFile = progress.file;
+					lastPct = pct;
+					onProgress?.({
+						status: `Downloading ${progress.file}`,
+						progress: pct,
+						file: progress.file
+					});
+				}
+			}
+		};
+		try {
+			onProgress?.({ status: "Loading processor..." });
+			this.processor = await suppressNoisyWarnings(() => AutoProcessor.from_pretrained(repoPath, { progress_callback: progressCallback }));
+			onProgress?.({ status: "Loading vision model..." });
+			this.visionModel = await suppressNoisyWarnings(() => AutoModelForImageTextToText.from_pretrained(repoPath, {
+				device: tfDevice,
+				progress_callback: progressCallback
+			}));
+			this.isVisionModel = true;
+			this.useDirect = true;
+			this._deviceMode = tfDevice === "webgpu" ? "webgpu" : tfDevice;
+			this.currentModel = modelId;
+			this.modelConfig = config;
+			onProgress?.({ status: `Ready (Vision, ${tfDevice.toUpperCase()})!` });
+		} catch (err) {
+			if (tfDevice !== fallbackDevice) {
+				onProgress?.({ status: `Vision model: Using ${fallbackDevice.toUpperCase()}...` });
+				this.processor = await suppressNoisyWarnings(() => AutoProcessor.from_pretrained(repoPath, { progress_callback: progressCallback }));
+				this.visionModel = await suppressNoisyWarnings(() => AutoModelForImageTextToText.from_pretrained(repoPath, {
+					device: fallbackDevice,
+					progress_callback: progressCallback
+				}));
+				this.isVisionModel = true;
+				this.useDirect = true;
+				this._deviceMode = fallbackDevice;
+				this.currentModel = modelId;
+				this.modelConfig = config;
+				onProgress?.({ status: `Ready (Vision, ${fallbackDevice.toUpperCase()})!` });
+			} else throw err;
+		}
+	}
+	/**
+	* Check if a model is loaded
+	*/
+	isLoaded() {
+		return this.generator !== null || this.useDirect && this.model !== null || this.chromeBackend !== null || this.isVisionModel && this.visionModel !== null;
+	}
+	/**
+	* Check if current model supports vision
+	*/
+	supportsVision() {
+		return this.isVisionModel && this.modelConfig?.supportsVision === true;
+	}
+	/**
+	* Get current model info
+	*/
+	getModelInfo() {
+		return this.modelConfig;
+	}
+	/**
+	* Get current device mode (webgpu, cpu, or wasm)
+	*/
+	getDeviceMode() {
+		return this._deviceMode;
+	}
+	/**
+	* Get dtype used for current model
+	*/
+	getDtype() {
+		return this._deviceMode === "webgpu" ? "q4f16" : "q4";
+	}
+	/**
+	* Get response cache statistics
+	*/
+	getResponseCacheStats() {
+		const cache = getGlobalCache();
+		const stats = cache.getStats();
+		return {
+			hits: stats.hits,
+			misses: stats.misses,
+			size: stats.size,
+			hitRate: cache.getHitRate()
+		};
+	}
+	/**
+	* Clear the response cache (for cached generate() results)
+	*/
+	clearResponseCache() {
+		getGlobalCache().clear();
+	}
+	/**
+	* Get Chrome backend status (if using WebGPU via Chrome)
+	*/
+	getChromeStatus() {
+		if (!this.chromeBackend) return null;
+		return this.chromeBackend.getStatus();
+	}
+	/**
+	* Get Chrome memory usage (if using WebGPU via Chrome)
+	* Returns JS heap memory in bytes
+	*/
+	async getChromeMemory() {
+		if (!this.chromeBackend) return null;
+		return this.chromeBackend.getMemoryUsage();
+	}
+	/**
+	* Get memory usage in GB (if using WebGPU via Chrome)
+	*/
+	async getMemoryUsage() {
+		if (!this.chromeBackend) return null;
+		return this.chromeBackend.getMemoryStats();
+	}
+	/**
+	* Clear KV cache to free memory
+	* This will reset the conversation context but free up memory
+	*/
+	async clearCache() {
+		if (this.chromeBackend) await this.chromeBackend.reset();
+	}
+	/**
+	* Check memory usage and cleanup if needed
+	* @param thresholdGB Memory threshold in GB (default: 8)
+	* @returns true if cleanup was performed
+	*/
+	async checkMemoryAndCleanup(thresholdGB = 8) {
+		if (!this.chromeBackend) return false;
+		return this.chromeBackend.checkMemoryAndCleanup(thresholdGB);
+	}
+	/**
+	* Generate text (automatically routes to vision generation if images provided)
+	*
+	* @example
+	* ```ts
+	* // Text generation
+	* const result = await g.generate("Hello!");
+	*
+	* // Vision generation (with vision model)
+	* const result = await g.generate("What's in this image?", {
+	*   images: [{ source: "https://example.com/cat.jpg" }]
+	* });
+	* ```
+	*/
+	async generate(prompt, options = {}) {
+		if (!this.isLoaded()) await this.loadModel(this.config.model || "qwen3-0.6b");
+		const { images } = options;
+		if (images?.length && this.isVisionModel && !this.chromeBackend) return this.generateWithVision(prompt, options);
+		if (images?.length && !this.isVisionModel) {}
+		const { maxTokens = 256, temperature = .7, topP = .9, topK = 50, thinking = false, system, cache = false, cacheTtl } = options;
+		if (cache && !options.onToken && !images?.length) {
+			const cacheKey = generateCacheKey(prompt, this.currentModel || "", {
+				maxTokens,
+				temperature,
+				topP,
+				topK,
+				system,
+				thinking
+			});
+			const cached = getGlobalCache().get(cacheKey);
+			if (cached) return cached;
+		}
+		const startTime = performance.now();
+		try {
+			let rawText = "";
+			if (this.chromeBackend) try {
+				rawText = await this.chromeBackend.generate(prompt, {
+					maxTokens,
+					temperature,
+					topP,
+					topK,
+					thinking,
+					system,
+					images: images?.map((img) => img.source),
+					onToken: options.onToken ? (t) => options.onToken?.(t.text) : void 0
+				});
+			} catch (chromeErr) {
+				if (chromeErr?.message === "CHROME_BACKEND_DEAD" || !this.chromeBackend?.isAlive()) {
+					await this.chromeBackend?.dispose().catch(() => {});
+					this.chromeBackend = null;
+					this._deviceMode = "cpu";
+					this.generator = await pipeline$1("text-generation", this.currentModel || "qwen3-0.6b", {
+						dtype: "q4",
+						device: "cpu"
+					});
+					return this.generate(prompt, options);
+				}
+				throw chromeErr;
+			}
+			else if (this.useDirect && this.model && this.tokenizer) {
+				const messages = this.buildMessages(prompt, {
+					...options,
+					thinking
+				});
+				const inputs = this.tokenizer.apply_chat_template(messages, {
+					add_generation_prompt: true,
+					return_dict: true,
+					enable_thinking: thinking
+				});
+				const output = await this.model.generate({
+					...inputs,
+					max_new_tokens: maxTokens,
+					temperature: temperature > 0 ? temperature : void 0,
+					top_p: topP,
+					top_k: topK,
+					do_sample: temperature > 0
+				});
+				const inputLength = inputs.input_ids.dims?.[1] || inputs.input_ids.data?.length || 0;
+				const outputTokens = output.slice(null, [inputLength, null]);
+				rawText = this.tokenizer.batch_decode(outputTokens, { skip_special_tokens: true })[0] || "";
+				if (rawText.toLowerCase().includes("assistant")) {
+					const match = rawText.match(/assistant[:\s]*([\s\S]*)/i);
+					if (match) rawText = match[1].trim();
+				}
+			} else if (this.generator) {
+				const formattedPrompt = this.formatPrompt(prompt, {
+					...options,
+					thinking
+				});
+				const output = await this.generator(formattedPrompt, {
+					max_new_tokens: maxTokens,
+					temperature,
+					top_p: topP,
+					top_k: topK,
+					do_sample: temperature > 0,
+					return_full_text: false
+				});
+				if (Array.isArray(output) && output[0]) {
+					const result$1 = output[0];
+					if (Array.isArray(result$1.generated_text)) rawText = result$1.generated_text.at(-1)?.content || "";
+					else rawText = result$1.generated_text || "";
+				}
+			} else throw new Error("No model loaded");
+			const totalTime = performance.now() - startTime;
+			rawText = this.cleanOutput(rawText);
+			const { thinking: thinkingText, response } = this.parseThinking(rawText);
+			const finalThinking = thinking ? thinkingText : void 0;
+			const tokensGenerated = Math.ceil(response.length / 4);
+			this.stats.prompts += 1;
+			this.stats.tokensOut += tokensGenerated;
+			this.stats.totalTime += totalTime;
+			this.stats.avgSpeed = this.stats.tokensOut / this.stats.totalTime * 1e3;
+			const result = {
+				text: response,
+				thinking: finalThinking,
+				tokensGenerated,
+				tokensPerSecond: tokensGenerated / totalTime * 1e3,
+				totalTime,
+				finishReason: "stop",
+				provider: "local",
+				cached: false
+			};
+			if (cache && !options.onToken && !images?.length) {
+				const cacheKey = generateCacheKey(prompt, this.currentModel || "", {
+					maxTokens,
+					temperature,
+					topP,
+					topK,
+					system,
+					thinking
+				});
+				getGlobalCache().set(cacheKey, result, cacheTtl);
+			}
+			return result;
+		} catch (_error) {
+			return {
+				text: "",
+				tokensGenerated: 0,
+				tokensPerSecond: 0,
+				totalTime: performance.now() - startTime,
+				finishReason: "error",
+				provider: "local",
+				cached: false
+			};
+		}
+	}
+	/**
+	* Stream text generation (simulated token-by-token)
+	*
+	* Note: Yields the raw output including <think> tags if thinking mode is enabled.
+	* The final result has parsed thinking separated out.
+	*/
+	async *stream(prompt, options = {}) {
+		if (!this.isLoaded()) await this.loadModel(this.config.model || "qwen3-0.6b");
+		const startTime = performance.now();
+		if (this.chromeBackend) {
+			let fullText = "";
+			const tokenQueue = [];
+			let resolveNext = null;
+			let done = false;
+			const generatePromise = this.chromeBackend.generate(prompt, {
+				...options,
+				images: options.images?.map((img) => img.source),
+				onToken: (token) => {
+					fullText += token.text;
+					if (resolveNext) {
+						resolveNext(token.text);
+						resolveNext = null;
+					} else tokenQueue.push(token.text);
+				}
+			}).then(() => {
+				done = true;
+				if (resolveNext) resolveNext(null);
+			}).catch((err) => {
+				done = true;
+				if (resolveNext) resolveNext(null);
+				throw err;
+			});
+			while (!done || tokenQueue.length > 0) if (tokenQueue.length > 0) {
+				const token = tokenQueue.shift();
+				yield token;
+				options.onToken?.(token);
+			} else if (!done) {
+				const token = await new Promise((resolve) => {
+					resolveNext = resolve;
+				});
+				if (token) {
+					yield token;
+					options.onToken?.(token);
+				}
+			}
+			await generatePromise;
+			const { thinking: thinkingText, response } = this.parseThinking(fullText);
+			const tokensGenerated = Math.ceil(response.length / 4);
+			const totalTime = performance.now() - startTime;
+			return {
+				text: response,
+				thinking: options.thinking ? thinkingText : void 0,
+				tokensGenerated,
+				totalTime,
+				tokensPerSecond: tokensGenerated / totalTime * 1e3,
+				finishReason: "stop"
+			};
+		}
+		const result = await this.generateRaw(prompt, options);
+		const words = result.rawText.split(/(\s+)/);
+		for (const word of words) if (word) {
+			yield word;
+			options.onToken?.(word);
+		}
+		return result.result;
+	}
+	/**
+	* Internal: Generate with raw text access for streaming
+	*/
+	async generateRaw(prompt, options = {}) {
+		const { maxTokens = 256, temperature = .7, topP = .9, topK = 50, thinking = false } = options;
+		const startTime = performance.now();
+		const formattedPrompt = this.formatPrompt(prompt, {
+			...options,
+			thinking
+		});
+		try {
+			const output = await this.generator?.(formattedPrompt, {
+				max_new_tokens: maxTokens,
+				temperature,
+				top_p: topP,
+				top_k: topK,
+				do_sample: temperature > 0,
+				return_full_text: false
+			});
+			const totalTime = performance.now() - startTime;
+			let rawText = "";
+			if (Array.isArray(output) && output[0]) {
+				const result = output[0];
+				if (Array.isArray(result.generated_text)) rawText = result.generated_text.at(-1)?.content || "";
+				else rawText = result.generated_text || "";
+			}
+			rawText = this.cleanOutput(rawText);
+			const { thinking: thinkingText, response } = this.parseThinking(rawText);
+			const finalThinking = thinking ? thinkingText : void 0;
+			const tokensGenerated = Math.ceil(response.length / 4);
+			this.stats.prompts += 1;
+			this.stats.tokensOut += tokensGenerated;
+			this.stats.totalTime += totalTime;
+			this.stats.avgSpeed = this.stats.tokensOut / this.stats.totalTime * 1e3;
+			return {
+				rawText,
+				result: {
+					text: response,
+					thinking: finalThinking,
+					tokensGenerated,
+					tokensPerSecond: tokensGenerated / totalTime * 1e3,
+					totalTime,
+					finishReason: "stop",
+					provider: "local",
+					cached: false
+				}
+			};
+		} catch (_error) {
+			return {
+				rawText: "",
+				result: {
+					text: "",
+					tokensGenerated: 0,
+					tokensPerSecond: 0,
+					totalTime: performance.now() - startTime,
+					finishReason: "error",
+					provider: "local",
+					cached: false
+				}
+			};
+		}
+	}
+	/**
+	* Generate text from images using a vision model
+	* Called automatically by generate() when images are provided
+	*/
+	async generateWithVision(prompt, options) {
+		if (!(this.processor && this.visionModel)) throw new Error("Vision model not loaded. Load a vision model first.");
+		const { images = [], maxTokens = 2048, temperature = .7, topP = .9, topK = 20, system } = options;
+		const startTime = performance.now();
+		try {
+			const content = [];
+			for (let i = 0; i < images.length; i += 1) content.push({ type: "image" });
+			content.push({
+				type: "text",
+				text: prompt
+			});
+			const messages = [...system ? [{
+				role: "system",
+				content: system
+			}] : [], {
+				role: "user",
+				content
+			}];
+			const chatPrompt = this.processor.apply_chat_template(messages);
+			const loadedImages = await Promise.all(images.map(async (img) => await RawImage.fromURL(img.source)));
+			const inputs = await this.processor(loadedImages.length === 1 ? loadedImages[0] : loadedImages, chatPrompt, { add_special_tokens: false });
+			let fullText = "";
+			const streamer = options.onToken ? new TextStreamer(this.processor.tokenizer, {
+				skip_prompt: true,
+				skip_special_tokens: true,
+				callback_function: (text$1) => {
+					fullText += text$1;
+					options.onToken?.(text$1);
+				}
+			}) : void 0;
+			const outputs = await this.visionModel.generate({
+				...inputs,
+				max_new_tokens: maxTokens,
+				temperature: temperature > 0 ? temperature : void 0,
+				top_p: topP,
+				top_k: topK,
+				do_sample: temperature > 0,
+				...streamer ? { streamer } : {}
+			});
+			const inputLength = inputs.input_ids.dims?.at(-1) || 0;
+			const text = this.processor.batch_decode(outputs.slice(null, [inputLength, null]), { skip_special_tokens: true })[0] || fullText || "";
+			const totalTime = performance.now() - startTime;
+			const tokensGenerated = Math.ceil(text.length / 4);
+			this.stats.prompts += 1;
+			this.stats.tokensOut += tokensGenerated;
+			this.stats.totalTime += totalTime;
+			this.stats.avgSpeed = this.stats.tokensOut / this.stats.totalTime * 1e3;
+			return {
+				text: this.cleanOutput(text),
+				tokensGenerated,
+				tokensPerSecond: tokensGenerated / totalTime * 1e3,
+				totalTime,
+				finishReason: "stop",
+				provider: "local",
+				cached: false
+			};
+		} catch (_error) {
+			return {
+				text: "",
+				tokensGenerated: 0,
+				tokensPerSecond: 0,
+				totalTime: performance.now() - startTime,
+				finishReason: "error",
+				provider: "local",
+				cached: false
+			};
+		}
+	}
+	/**
+	* Generate structured JSON output
+	*/
+	async json(prompt, options) {
+		const { schema, retries = 3, temperature = .3 } = options;
+		const systemPrompt = `You are a JSON generator. You MUST respond with valid JSON only.
+No explanations, no markdown, no code blocks. Just pure JSON.
+The JSON must conform to this schema: ${JSON.stringify(zodToJsonSchema(schema))}`;
+		for (let attempt = 0; attempt < retries; attempt += 1) {
+			const result = await this.generate(prompt, {
+				system: options.system || systemPrompt,
+				temperature,
+				maxTokens: 1e3
+			});
+			try {
+				const jsonStr = extractJson(result.text);
+				const parsed = JSON.parse(jsonStr);
+				return schema.parse(parsed);
+			} catch (error) {
+				if (attempt === retries - 1) throw new Error(`Failed to generate valid JSON after ${retries} attempts: ${error}`);
+			}
+		}
+		throw new Error("Failed to generate valid JSON");
+	}
+	/**
+	* Generate embeddings
+	*/
+	async embed(text, options = {}) {
+		if (!this.embedder) this.embedder = await pipeline$1("feature-extraction", options.model || "Xenova/all-MiniLM-L6-v2");
+		const startTime = performance.now();
+		const output = await this.embedder(text, {
+			pooling: "mean",
+			normalize: options.normalize !== false
+		});
+		return {
+			vector: Array.from(output.data),
+			text,
+			totalTime: performance.now() - startTime
+		};
+	}
+	/**
+	* Generate embeddings for multiple texts
+	*/
+	async embedBatch(texts, options = {}) {
+		const results = [];
+		for (const text of texts) results.push(await this.embed(text, options));
+		return results;
+	}
+	/**
+	* Get session stats
+	*/
+	getStats() {
+		return { ...this.stats };
+	}
+	/**
+	* Get system info
+	*/
+	getInfo() {
+		return {
+			version: "1.0.0",
+			model: this.modelConfig,
+			device: {
+				backend: "transformers.js",
+				gpu: null,
+				vram: null,
+				status: this.isLoaded() ? "ready" : "loading"
+			},
+			context: {
+				max: this.modelConfig?.contextLength || 0,
+				used: 0,
+				available: this.modelConfig?.contextLength || 0
+			},
+			cache: {
+				location: "~/.gerbil/models",
+				size: "0 MB",
+				modelCount: 0
+			}
+		};
+	}
+	/**
+	* Reset stats
+	*/
+	resetStats() {
+		this.stats = {
+			prompts: 0,
+			tokensIn: 0,
+			tokensOut: 0,
+			avgSpeed: 0,
+			totalTime: 0,
+			cacheHits: 0,
+			cacheMisses: 0
+		};
+	}
+	tts = null;
+	ttsModelId = "kokoro-82m";
+	/**
+	* Load TTS model for text-to-speech synthesis
+	*
+	* @example
+	* ```ts
+	* // Load default (Kokoro)
+	* await g.loadTTS({ onProgress: (p) => console.log(p.status) });
+	*
+	* // Load Supertonic (faster, 44kHz output)
+	* await g.loadTTS({ model: "supertonic-66m" });
+	*
+	* const result = await g.speak("Hello world");
+	* // result.audio = Float32Array, result.sampleRate = 24000 or 44100
+	* ```
+	*/
+	async loadTTS(options = {}) {
+		const modelId = options.model || "kokoro-82m";
+		if (this.tts && this.ttsModelId !== modelId) {
+			await this.tts.dispose();
+			this.tts = null;
+		}
+		if (this.tts?.isLoaded()) return;
+		this.ttsModelId = modelId;
+		const { createTTS } = await import("./tts-5yWeP_I0.mjs");
+		if (!this.tts) this.tts = createTTS(modelId);
+		await this.tts.load(options);
+	}
+	/**
+	* Ensure TTS model is loaded (lazy loading)
+	*/
+	async ensureTTSLoaded(options) {
+		if (!this.tts?.isLoaded()) await this.loadTTS(options);
+	}
+	/**
+	* Generate speech from text
+	*
+	* @example
+	* ```ts
+	* const result = await g.speak("Hello world", { voice: "af_bella" });
+	* // result.audio = Float32Array PCM
+	* // result.sampleRate = 24000
+	* // result.duration = seconds
+	* ```
+	*/
+	async speak(text, options = {}) {
+		await this.ensureTTSLoaded({ onProgress: options.onProgress });
+		return this.tts.speak(text, options);
+	}
+	/**
+	* Stream speech generation (yields audio chunks as they're generated)
+	*
+	* @example
+	* ```ts
+	* for await (const chunk of g.speakStream("Long text...")) {
+	*   // chunk.samples = Float32Array
+	*   // chunk.isFinal = boolean
+	*   playChunk(chunk);
+	* }
+	* ```
+	*/
+	async *speakStream(text, options = {}) {
+		await this.ensureTTSLoaded({ onProgress: options.onProgress });
+		return yield* this.tts.speakStream(text, options);
+	}
+	/**
+	* Get list of available TTS voices
+	*/
+	listVoices() {
+		if (!this.tts) return KOKORO_VOICES_DEFAULT;
+		return this.tts.listVoices();
+	}
+	/**
+	* Check if TTS model is loaded
+	*/
+	isTTSLoaded() {
+		return this.tts?.isLoaded() ?? false;
+	}
+	/**
+	* Get current TTS model info
+	*/
+	getTTSModelInfo() {
+		if (!this.tts) return null;
+		return {
+			id: this.ttsModelId,
+			loaded: this.tts.isLoaded(),
+			device: this.tts.isLoaded() ? this.tts.getDeviceMode() : void 0
+		};
+	}
+	/**
+	* List available TTS models
+	*/
+	async listTTSModels() {
+		const { TTS_MODELS } = await import("./tts-5yWeP_I0.mjs");
+		return Object.values(TTS_MODELS).map((m) => ({
+			id: m.id,
+			description: m.description,
+			sampleRate: m.sampleRate,
+			voiceCount: m.voices.length
+		}));
+	}
+	stt = null;
+	/**
+	* Load STT model for speech-to-text transcription
+	*
+	* @example
+	* ```ts
+	* await g.loadSTT({
+	*   onProgress: (p) => console.log(p.status)
+	* });
+	*
+	* const result = await g.transcribe(audioData);
+	* console.log(result.text);
+	* ```
+	*/
+	async loadSTT(modelId, options = {}) {
+		if (this.stt?.isLoaded()) return;
+		const { WhisperSTT } = await import("./stt-KzSoNvwI.mjs");
+		if (!this.stt) this.stt = new WhisperSTT(modelId);
+		await this.stt.load(options);
+	}
+	/**
+	* Ensure STT model is loaded (lazy loading)
+	*/
+	async ensureSTTLoaded(modelId, options) {
+		if (!this.stt?.isLoaded()) await this.loadSTT(modelId, options);
+	}
+	/**
+	* Transcribe audio to text
+	*
+	* @param audio - Audio data as Float32Array (16kHz mono) or Uint8Array (WAV file)
+	* @param options - Transcription options
+	*
+	* @example
+	* ```ts
+	* // From Float32Array (16kHz mono)
+	* const result = await g.transcribe(audioData);
+	* console.log(result.text);
+	*
+	* // With timestamps
+	* const result = await g.transcribe(audioData, { timestamps: true });
+	* for (const seg of result.segments) {
+	*   console.log(`[${seg.start}s] ${seg.text}`);
+	* }
+	*
+	* // From WAV file
+	* const wavData = fs.readFileSync("audio.wav");
+	* const result = await g.transcribe(new Uint8Array(wavData));
+	* ```
+	*/
+	async transcribe(audio, options = {}) {
+		await this.ensureSTTLoaded(void 0, { onProgress: options.onProgress });
+		return this.stt.transcribe(audio, options);
+	}
+	/**
+	* Create a streaming transcription session
+	*
+	* Transcribes audio in real-time by processing chunks at regular intervals.
+	* Perfect for live captioning, call transcription, or real-time subtitles.
+	*
+	* @param options - Streaming options
+	* @returns Streaming session controller
+	*
+	* @example
+	* ```ts
+	* const session = await g.createStreamingTranscription({
+	*   chunkDuration: 3000,  // Transcribe every 3 seconds
+	*   onChunk: (text, idx) => console.log(`Chunk ${idx}: ${text}`),
+	*   onTranscript: (fullText) => console.log("Full:", fullText),
+	* });
+	*
+	* // Feed audio data as it comes in
+	* session.feedAudio(audioChunk);
+	*
+	* // Start automatic interval-based transcription
+	* session.start();
+	*
+	* // Later, stop and get final transcript
+	* const finalText = await session.stop();
+	* ```
+	*/
+	async createStreamingTranscription(options = {}) {
+		await this.ensureSTTLoaded();
+		return this.stt.createStreamingSession(options);
+	}
+	/**
+	* Get list of available STT models
+	*/
+	async listSTTModels() {
+		const { WhisperSTT } = await import("./stt-KzSoNvwI.mjs");
+		return WhisperSTT.listModels();
+	}
+	/**
+	* Check if STT model is loaded
+	*/
+	isSTTLoaded() {
+		return this.stt?.isLoaded() ?? false;
+	}
+	/**
+	* Get current STT model info
+	*/
+	getSTTModelInfo() {
+		if (!this.stt) return null;
+		return {
+			id: this.stt.getModelInfo().id,
+			loaded: this.stt.isLoaded(),
+			device: this.stt.isLoaded() ? this.stt.getDeviceMode() : void 0
+		};
+	}
+	/**
+	* Record audio from microphone and transcribe
+	*
+	* @example
+	* ```ts
+	* // Record for 5 seconds and transcribe
+	* const result = await g.listen(5000);
+	* console.log(result.text);
+	*
+	* // Use with voice chat
+	* const userInput = await g.listen(10000);
+	* const response = await g.generate(userInput.text);
+	* await g.speak(response.text);
+	* ```
+	*/
+	async listen(durationMs = 5e3, options = {}) {
+		const { Microphone, isSoxAvailable } = await import("./microphone-D-6y9aiE.mjs");
+		if (!isSoxAvailable()) throw new Error("Microphone recording requires SoX. Install with:\n  macOS: brew install sox\n  Ubuntu: sudo apt install sox\n  Windows: https://sox.sourceforge.net/");
+		options.onProgress?.("Starting microphone...");
+		const mic = new Microphone({ sampleRate: 16e3 });
+		await mic.start();
+		options.onProgress?.(`Recording for ${(durationMs / 1e3).toFixed(1)}s...`);
+		await new Promise((r) => setTimeout(r, durationMs));
+		options.onProgress?.("Processing audio...");
+		const { audio } = await mic.stop();
+		options.onProgress?.("Transcribing...");
+		return this.transcribe(audio, { onProgress: (p) => options.onProgress?.(p.status || "Transcribing...") });
+	}
+	/**
+	* Check if microphone recording is available
+	*/
+	async isMicrophoneAvailable() {
+		try {
+			const { isSoxAvailable } = await import("./microphone-D-6y9aiE.mjs");
+			return isSoxAvailable();
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Dispose of resources
+	* @param disconnect If true, also disconnect from shared browser (for clean script exit)
+	*/
+	async dispose(disconnect = false) {
+		if (this.chromeBackend) {
+			try {
+				await this.chromeBackend.dispose(disconnect);
+			} catch {}
+			this.chromeBackend = null;
+		}
+		if (this.generator) {
+			if (typeof this.generator.dispose === "function") try {
+				await this.generator.dispose();
+			} catch {}
+			this.generator = null;
+		}
+		if (this.embedder) {
+			if (typeof this.embedder.dispose === "function") try {
+				await this.embedder.dispose();
+			} catch {}
+			this.embedder = null;
+		}
+		if (this.visionModel) {
+			if (typeof this.visionModel.dispose === "function") try {
+				await this.visionModel.dispose();
+			} catch {}
+			this.visionModel = null;
+		}
+		if (this.processor) this.processor = null;
+		if (this.tts) {
+			try {
+				await this.tts.dispose();
+			} catch {}
+			this.tts = null;
+		}
+		if (this.stt) {
+			try {
+				this.stt.dispose();
+			} catch {}
+			this.stt = null;
+		}
+		this.currentModel = null;
+		this.modelConfig = null;
+		this.isVisionModel = false;
+	}
+	/**
+	* Shutdown the shared Chrome backend completely.
+	* Call this when your script/process is done to ensure proper cleanup.
+	* This closes the shared browser used for WebGPU acceleration.
+	*/
+	static async shutdown() {
+		const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+		await ChromeGPUBackend.closeSharedBrowser();
+	}
+	/**
+	* Get global WebGPU process info (all active backends)
+	* Useful for monitoring and debugging memory leaks
+	*/
+	static async getWebGPUProcesses() {
+		if (typeof window !== "undefined") return null;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return {
+				browser: ChromeGPUBackend.getGlobalBrowserStatus(),
+				backends: await ChromeGPUBackend.getAllBackendsInfo()
+			};
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Kill all WebGPU processes (for zombie cleanup)
+	* Use this if you suspect memory leaks from undisposed Gerbil instances
+	*/
+	static async killAllWebGPU() {
+		if (typeof window !== "undefined") return null;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return await ChromeGPUBackend.killAllBackends();
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Kill a specific WebGPU backend by index
+	* @param index Index of the backend to kill (0-based)
+	*/
+	static async killWebGPUBackend(index) {
+		if (typeof window !== "undefined") return false;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return await ChromeGPUBackend.killBackendByIndex(index);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get all Chrome pages across ALL Gerbil processes
+	* This provides cross-process visibility into WebGPU backends
+	*/
+	static async getAllChromePagesInfo() {
+		if (typeof window !== "undefined") return null;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return await ChromeGPUBackend.getAllChromePages();
+		} catch {
+			return null;
+		}
+	}
+	/**
+	* Kill a Chrome page by index (works across processes)
+	* @param index Index of the page to kill (0-based)
+	*/
+	static async killChromePage(index) {
+		if (typeof window !== "undefined") return false;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return await ChromeGPUBackend.killPageByIndex(index);
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Get total Chrome page count (all processes)
+	*/
+	static async getTotalChromePageCount() {
+		if (typeof window !== "undefined") return 0;
+		try {
+			const { ChromeGPUBackend } = await import("./chrome-backend-JEPeM2YE.mjs");
+			return await ChromeGPUBackend.getTotalPageCount();
+		} catch {
+			return 0;
+		}
+	}
+	formatPrompt(prompt, options) {
+		const system = options.system || "You are a helpful assistant.";
+		const isQwen = this.currentModel?.includes("qwen");
+		if (options.thinking && this.modelConfig?.supportsThinking) return `<|im_start|>system\n${`${system}\n\nThink step-by-step before answering. Wrap your reasoning in <think></think> tags, then provide your answer.`}<|im_end|>\n<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n`;
+		if (isQwen) return `<|im_start|>system\n${system}<|im_end|>\n<|im_start|>user\n${prompt} /no_think<|im_end|>\n<|im_start|>assistant\n`;
+		return `<|im_start|>system\n${system}<|im_end|>\n<|im_start|>user\n${prompt}<|im_end|>\n<|im_start|>assistant\n`;
+	}
+	buildMessages(prompt, options) {
+		const system = options.system || "You are a helpful assistant.";
+		const messages = [];
+		messages.push({
+			role: "system",
+			content: system
+		});
+		messages.push({
+			role: "user",
+			content: prompt
+		});
+		return messages;
+	}
+	parseThinking(text) {
+		const match = text.match(/<think>([\s\S]*?)<\/think>/);
+		if (match) return {
+			thinking: match[1].trim(),
+			response: text.replace(/<think>[\s\S]*?<\/think>/, "").trim()
+		};
+		const unclosedMatch = text.match(/<think>([\s\S]*)$/);
+		if (unclosedMatch) {
+			const thinking = unclosedMatch[1].trim();
+			const response = text.replace(/<think>[\s\S]*$/, "").trim();
+			return {
+				thinking: thinking || void 0,
+				response
+			};
+		}
+		return { response: text.replace(/<\/?think>/g, "").trim() };
+	}
+	cleanOutput(text) {
+		return text.replace(/<\|im_end\|>/g, "").replace(/<\|im_start\|>/g, "").replace(/<\|endoftext\|>/g, "").replace(/<\/s>/g, "").replace(/^\/no_think\s*/i, "").replace(/^assistant\s*/i, "").replace(/^\s*\/no_think\s*/gim, "").replace(/^\s*assistant\s*/gim, "").replace(/^(system|user|assistant):\s*/gim, "").trim();
+	}
+};
+
+//#endregion
+export { getGlobalCache as a, configureGlobalCache as i, ResponseCache as n, clearGlobalCache as r, Gerbil as t };
+//# sourceMappingURL=gerbil-yoSpRHgv.mjs.map