@tryhamster/gerbil 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/browser/{index.d.mts → index.d.ts}

@@ -1,6 +1,357 @@
-import { A as TranscribeSegment, C as SpeakResult, D as TTSModelConfig, E as SystemInfo, O as TranscribeOptions, S as SpeakOptions, T as StreamingTranscriptionSession, _ as ModelSource, a as FallbackConfig, b as STTModelConfig, c as GerbilConfig, d as ImageInput, f as JsonOptions, g as ModelConfig, h as LoadTTSOptions, i as EmbedResult, j as VoiceInfo, k as TranscribeResult, l as GerbilModelSettings, m as LoadSTTOptions, n as CacheConfig, o as GenerateOptions, p as LoadOptions, r as EmbedOptions, s as GenerateResult, t as AudioChunk, u as GerbilProviderSettings, v as ModelStats, w as StreamingTranscriptionOptions, x as SessionStats, y as ProgressInfo } from "../types-s6Py2_DL.mjs";
-import { t as BUILTIN_MODELS } from "../models-CE0fBq0U.mjs";
+import { z } from "zod";
 
+//#region src/core/types.d.ts
+
+type ModelConfig = {
+  id: string;
+  repo: string;
+  description: string;
+  size: string;
+  contextLength: number;
+  supportsThinking: boolean;
+  supportsJson: boolean;
+  /** Whether model supports vision/image input */
+  supportsVision?: boolean;
+  /** Vision encoder size (for display, e.g., "0.4B") */
+  visionEncoderSize?: string;
+  family: "qwen" | "smollm" | "phi" | "mistral" | "llama" | "other";
+};
+type ModelSource = {
+  type: "builtin" | "huggingface" | "local";
+  path: string;
+};
+type ImageInput = {
+  /** Image source: URL, base64 data URI, or local file path */
+  source: string;
+  /** Optional alt text for context */
+  alt?: string;
+};
+type GenerateOptions = {
+  /** Maximum tokens to generate (default: 256) */
+  maxTokens?: number;
+  /** Temperature for sampling, 0-2 (default: 0.7) */
+  temperature?: number;
+  /** Top-p sampling (default: 0.9) */
+  topP?: number;
+  /** Top-k sampling (default: 50) */
+  topK?: number;
+  /** Stop sequences */
+  stopSequences?: string[];
+  /** System prompt */
+  system?: string;
+  /** Enable thinking/reasoning mode (Qwen3) */
+  thinking?: boolean;
+  /** Callback for each token (streaming) */
+  onToken?: (token: string) => void;
+  /** Images to include (only used if model supports vision) */
+  images?: ImageInput[];
+  /** Enable response caching (default: false) */
+  cache?: boolean;
+  /** Cache TTL in milliseconds (default: 5 minutes) */
+  cacheTtl?: number;
+};
+type GenerateResult = {
+  /** Generated text */
+  text: string;
+  /** Thinking/reasoning (if enabled) */
+  thinking?: string;
+  /** Tokens generated */
+  tokensGenerated: number;
+  /** Generation speed */
+  tokensPerSecond: number;
+  /** Total time in ms */
+  totalTime: number;
+  /** Why generation stopped */
+  finishReason: "stop" | "length" | "error";
+  /** Which provider was used (for hybrid mode) */
+  provider?: "local" | "openai" | "anthropic";
+  /** Whether result came from cache */
+  cached?: boolean;
+};
+type JsonOptions<T = unknown> = {
+  /** Zod schema for validation */
+  schema: z.ZodType<T>;
+  /** Number of retries on invalid JSON (default: 3) */
+  retries?: number;
+  /** Temperature (lower = more deterministic, default: 0.3) */
+  temperature?: number;
+  /** System prompt override */
+  system?: string;
+};
+type EmbedOptions = {
+  /** Model to use for embeddings */
+  model?: string;
+  /** Normalize vectors (default: true) */
+  normalize?: boolean;
+};
+type EmbedResult = {
+  /** Embedding vector */
+  vector: number[];
+  /** Original text */
+  text: string;
+  /** Time in ms */
+  totalTime: number;
+};
+type LoadOptions = {
+  /** Progress callback */
+  onProgress?: (info: ProgressInfo) => void;
+  /** Device: 'auto', 'gpu', 'cpu', 'webgpu' (default: 'auto') */
+  device?: "auto" | "gpu" | "cpu" | "webgpu";
+  /** Quantization: 'q4', 'q8', 'fp16', 'fp32' (default: 'q4') */
+  dtype?: "q4" | "q8" | "fp16" | "fp32";
+  /** Override context length */
+  contextLength?: number;
+};
+type ProgressInfo = {
+  status: string;
+  progress?: number;
+  file?: string;
+  loaded?: number;
+  total?: number;
+};
+type GerbilConfig = {
+  /** Default model */
+  model?: string;
+  /** Default device */
+  device?: "auto" | "gpu" | "cpu";
+  /** Default quantization */
+  dtype?: "q4" | "q8" | "fp16" | "fp32";
+  /** Cache configuration */
+  cache?: CacheConfig;
+  /** Fallback configuration */
+  fallback?: FallbackConfig;
+};
+type CacheConfig = {
+  /** Enable caching (default: true) */
+  enabled?: boolean;
+  /** Time-to-live in seconds (default: 3600) */
+  ttl?: number;
+  /** Max cache size (default: "500mb") */
+  maxSize?: string;
+  /** Storage backend */
+  storage?: "memory" | "disk" | "redis";
+  /** Redis URL (if storage is redis) */
+  redisUrl?: string;
+};
+type FallbackConfig = {
+  /** Fallback provider */
+  provider: "openai" | "anthropic";
+  /** API key */
+  apiKey: string;
+  /** Model to use */
+  model: string;
+  /** When to fallback */
+  when: "timeout" | "error" | "always-verify";
+  /** Timeout in ms before fallback (default: 5000) */
+  timeout?: number;
+};
+type SessionStats = {
+  prompts: number;
+  tokensIn: number;
+  tokensOut: number;
+  avgSpeed: number;
+  totalTime: number;
+  cacheHits: number;
+  cacheMisses: number;
+};
+type ModelStats = {
+  modelId: string;
+  avgSpeed: number;
+  totalGenerations: number;
+  totalTokens: number;
+};
+type SystemInfo = {
+  version: string;
+  model: ModelConfig | null;
+  device: {
+    backend: string;
+    gpu: string | null;
+    vram: string | null;
+    status: "ready" | "loading" | "error";
+  };
+  context: {
+    max: number;
+    used: number;
+    available: number;
+  };
+  cache: {
+    location: string;
+    size: string;
+    modelCount: number;
+  };
+};
+type GerbilModelSettings = {
+  /** Enable thinking mode */
+  thinking?: boolean;
+  /** Device to use */
+  device?: "auto" | "gpu" | "cpu";
+  /** Quantization level */
+  dtype?: "q4" | "q8" | "fp16" | "fp32";
+};
+type GerbilProviderSettings = {
+  /** Default device */
+  device?: "auto" | "gpu" | "cpu";
+  /** Default quantization */
+  dtype?: "q4" | "q8" | "fp16" | "fp32";
+};
+type VoiceInfo = {
+  /** Voice ID (e.g., "af_bella", "am_adam") */
+  id: string;
+  /** Display name (e.g., "Bella", "Adam") */
+  name: string;
+  /** Gender: male, female, or neutral */
+  gender: "male" | "female" | "neutral";
+  /** Language code (e.g., "en", "en-us", "zh") */
+  language: string;
+  /** Optional description */
+  description?: string;
+  /** Speaker embedding file name (internal) */
+  embeddingFile?: string;
+};
+type TTSModelConfig = {
+  /** Model ID (e.g., "kokoro-82m") */
+  id: string;
+  /** HuggingFace repo path */
+  repo: string;
+  /** Human-readable description */
+  description: string;
+  /** Approximate model size */
+  size: string;
+  /** Output sample rate in Hz (e.g., 24000) */
+  sampleRate: number;
+  /** Available voices */
+  voices: VoiceInfo[];
+  /** Default voice ID */
+  defaultVoice: string;
+  /** Supported languages */
+  languages: string[];
+};
+type SpeakOptions = {
+  /** Voice ID to use (default: model's default voice) */
+  voice?: string;
+  /** Speech speed multiplier (0.5 = half speed, 2.0 = double speed, default: 1.0) */
+  speed?: number;
+  /** Progress callback */
+  onProgress?: (info: ProgressInfo) => void;
+  /** Callback for audio chunks during streaming */
+  onAudioChunk?: (chunk: AudioChunk) => void;
+};
+type AudioChunk = {
+  /** Raw PCM audio samples (Float32Array) */
+  samples: Float32Array;
+  /** Sample rate in Hz */
+  sampleRate: number;
+  /** Chunk index (0-based) */
+  index: number;
+  /** Whether this is the final chunk */
+  isFinal: boolean;
+};
+type SpeakResult = {
+  /** Raw PCM audio samples (Float32Array) */
+  audio: Float32Array;
+  /** Sample rate in Hz */
+  sampleRate: number;
+  /** Audio duration in seconds */
+  duration: number;
+  /** Voice used */
+  voice: string;
+  /** Total processing time in ms */
+  totalTime: number;
+};
+type LoadTTSOptions = {
+  /** Progress callback */
+  onProgress?: (info: ProgressInfo) => void;
+  /** Device: 'auto', 'webgpu', 'cpu' (default: 'auto') */
+  device?: "auto" | "webgpu" | "cpu";
+};
+type STTModelConfig = {
+  /** Model ID (e.g., "whisper-tiny.en") */
+  id: string;
+  /** HuggingFace repo path */
+  repo: string;
+  /** Human-readable description */
+  description: string;
+  /** Model size (e.g., "39M", "244M") */
+  size: string;
+  /** Whether model supports multiple languages */
+  multilingual: boolean;
+  /** Supported languages (ISO 639-1 codes) */
+  languages: string[];
+  /** Expected sample rate (default: 16000) */
+  sampleRate: number;
+};
+type TranscribeOptions = {
+  /** Language hint (ISO 639-1 code like "en", "es", "fr") - only for multilingual models */
+  language?: string;
+  /** Return word/segment timestamps */
+  timestamps?: boolean;
+  /** Progress callback */
+  onProgress?: (info: ProgressInfo) => void;
+};
+type TranscribeSegment = {
+  /** Segment text */
+  text: string;
+  /** Start time in seconds */
+  start: number;
+  /** End time in seconds */
+  end: number;
+};
+type TranscribeResult = {
+  /** Full transcribed text */
+  text: string;
+  /** Detected or specified language */
+  language: string;
+  /** Segments with timestamps (if timestamps option enabled) */
+  segments?: TranscribeSegment[];
+  /** Audio duration in seconds */
+  duration: number;
+  /** Total processing time in ms */
+  totalTime: number;
+};
+type LoadSTTOptions = {
+  /** Progress callback */
+  onProgress?: (info: ProgressInfo) => void;
+  /** Device: 'auto', 'webgpu', 'cpu' (default: 'auto') */
+  device?: "auto" | "webgpu" | "cpu";
+};
+type StreamingTranscriptionOptions = {
+  /** Interval between transcriptions in ms (default: 3000) */
+  chunkDuration?: number;
+  /** Minimum audio samples before transcribing (default: 8000 = 0.5s at 16kHz) */
+  minChunkSize?: number;
+  /** Callback for each transcribed chunk */
+  onChunk?: (text: string, chunkIndex: number) => void;
+  /** Callback with full accumulated transcript */
+  onTranscript?: (fullText: string) => void;
+  /** Callback on transcription error */
+  onError?: (error: string) => void;
+  /** Language hint (for multilingual models) */
+  language?: string;
+};
+type StreamingTranscriptionSession = {
+  /** Feed audio data to the buffer (Float32Array at 16kHz) */
+  feedAudio: (audio: Float32Array) => void;
+  /** Manually trigger transcription of buffered audio */
+  flush: () => Promise<string>;
+  /** Start automatic interval-based transcription */
+  start: () => void;
+  /** Stop transcription and return final transcript */
+  stop: () => Promise<string>;
+  /** Immediately abort without final transcription (for cleanup) */
+  abort: () => void;
+  /** Check if session is running */
+  isRunning: () => boolean;
+  /** Get current full transcript */
+  getTranscript: () => string;
+  /** Get number of chunks transcribed */
+  getChunkCount: () => number;
+  /** Reset session (clear buffer and transcript) */
+  reset: () => void;
+};
+//#endregion
+//#region src/core/models.d.ts
+declare const BUILTIN_MODELS: Record<string, ModelConfig>;
+//#endregion
 //#region src/browser/index.d.ts
 
 type WorkerProgress = {
@@ -655,4 +1006,4 @@ declare const _default: {
 };
 //#endregion
 export { AudioChunk, BUILTIN_MODELS, BrowserVoiceInfo, CacheConfig, CompleteOptions, EmbedOptions, EmbedResult, FallbackConfig, GenerateOptions, GenerateResult, GenerateStreamOptions, GerbilConfig, GerbilModelSettings, GerbilProviderSettings, GerbilWorker, GerbilWorkerOptions, ImageInput, JsonOptions, LoadOptions, LoadSTTOptions, LoadTTSOptions, LoadingProgress, Message, ModelConfig, ModelSource, ModelStats, ProgressInfo, STTModelConfig, STTProgress, SessionStats, SpeakOptions, SpeakResult, StreamingTranscriptionOptions, StreamingTranscriptionSession, SystemInfo, TTSModelConfig, TTSModelId, TTSProgress, TranscribeOptions, TranscribeResult, TranscribeSegment, UseChatOptions, UseChatReturn, UseCompletionOptions, UseCompletionReturn, UseSpeechOptions, UseSpeechReturn, UseVoiceChatOptions, UseVoiceChatReturn, UseVoiceInputOptions, UseVoiceInputReturn, VoiceChatMessage, VoiceInfo, WorkerComplete, WorkerProgress, WorkerToken, createAudioPlayer, createGerbilWorker, _default as default, getWebGPUInfo, isWebGPUSupported, playAudio, useChat, useCompletion, useSpeech, useVoiceChat, useVoiceInput };
-//# sourceMappingURL=index.d.mts.map
+//# sourceMappingURL=index.d.ts.map

package/dist/browser/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/core/types.ts","../../src/core/models.ts","../../src/browser/index.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/browser/{index.mjs → index.js}

@@ -1,5 +1,115 @@
-import { o as resolveModel, t as BUILTIN_MODELS } from "../models-BAtL8qsA.mjs";
+//#region src/core/models.ts
+const BUILTIN_MODELS = {
+	"qwen3-0.6b": {
+		id: "qwen3-0.6b",
+		repo: "onnx-community/Qwen3-0.6B-ONNX",
+		description: "Qwen3 0.6B - Best balance of speed and quality, supports thinking",
+		size: "~400MB",
+		contextLength: 32768,
+		supportsThinking: true,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"qwen2.5-0.5b": {
+		id: "qwen2.5-0.5b",
+		repo: "onnx-community/Qwen2.5-0.5B-Instruct",
+		description: "Qwen2.5 0.5B - Fast and capable",
+		size: "~350MB",
+		contextLength: 32768,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"qwen2.5-coder-0.5b": {
+		id: "qwen2.5-coder-0.5b",
+		repo: "onnx-community/Qwen2.5-Coder-0.5B-Instruct",
+		description: "Qwen2.5 Coder 0.5B - Optimized for code",
+		size: "~400MB",
+		contextLength: 32768,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "qwen"
+	},
+	"smollm2-360m": {
+		id: "smollm2-360m",
+		repo: "HuggingFaceTB/SmolLM2-360M-Instruct",
+		description: "SmolLM2 360M - Fast, good for simple tasks",
+		size: "~250MB",
+		contextLength: 8192,
+		supportsThinking: false,
+		supportsJson: false,
+		family: "smollm"
+	},
+	"smollm2-135m": {
+		id: "smollm2-135m",
+		repo: "HuggingFaceTB/SmolLM2-135M-Instruct",
+		description: "SmolLM2 135M - Fastest, basic generation",
+		size: "~100MB",
+		contextLength: 8192,
+		supportsThinking: false,
+		supportsJson: false,
+		family: "smollm"
+	},
+	"phi-3-mini": {
+		id: "phi-3-mini",
+		repo: "microsoft/Phi-3-mini-4k-instruct-onnx",
+		description: "Phi-3 Mini - High quality, larger model",
+		size: "~2.1GB",
+		contextLength: 4096,
+		supportsThinking: false,
+		supportsJson: true,
+		family: "phi"
+	},
+	"ministral-3b": {
+		id: "ministral-3b",
+		repo: "mistralai/Ministral-3-3B-Instruct-2512-ONNX",
+		description: "Ministral 3 3B - Vision + Reasoning, 256k context",
+		size: "~2.5GB",
+		contextLength: 262144,
+		supportsThinking: true,
+		supportsJson: true,
+		supportsVision: true,
+		visionEncoderSize: "0.4B",
+		family: "mistral"
+	}
+};
+/**
+* Parse model identifier and resolve to source
+*
+* Supported formats:
+* - "qwen3-0.6b" (built-in)
+* - "hf:org/model" (HuggingFace shorthand)
+* - "https://huggingface.co/org/model" (full URL)
+* - "file:./path/to/model" (local path)
+*/
+function resolveModel(modelId) {
+	if (BUILTIN_MODELS[modelId]) return {
+		type: "builtin",
+		path: BUILTIN_MODELS[modelId].repo
+	};
+	if (modelId.startsWith("hf:")) return {
+		type: "huggingface",
+		path: modelId.slice(3)
+	};
+	if (modelId.startsWith("https://huggingface.co/")) return {
+		type: "huggingface",
+		path: modelId.replace("https://huggingface.co/", "")
+	};
+	if (modelId.startsWith("file:")) return {
+		type: "local",
+		path: modelId.slice(5)
+	};
+	if (modelId.includes("/")) return {
+		type: "huggingface",
+		path: modelId
+	};
+	return {
+		type: "huggingface",
+		path: modelId
+	};
+}
 
+//#endregion
 //#region src/browser/index.ts
 /**
 * Gerbil Browser Support
@@ -1256,7 +1366,7 @@ function useSpeech(options = {}) {
 					message: `Loading ${isSupertonic ? "Supertonic" : "Kokoro"} TTS...`
 				});
 				if (isSupertonic) {
-					const { pipeline } = await import("@huggingface/transformers");
+					const { pipeline } = await import("https://cdn.jsdelivr.net/npm/@huggingface/transformers@3.8.1");
 					const tts = await pipeline("text-to-speech", config.repo, {
 						device: "webgpu",
 						progress_callback: (progress) => {
@@ -1642,7 +1752,7 @@ function useVoiceInput(options = {}) {
 					status: "loading",
 					message: "Loading STT model..."
 				});
-				const { WhisperSTT } = await import("../stt-KzSoNvwI.mjs");
+				const { WhisperSTT } = await import("../stt-BtklAjR2.js");
 				if (cancelled || !mountedRef.current) return;
 				const stt = new WhisperSTT(model);
 				await stt.load({ onProgress: (p) => {
@@ -1778,7 +1888,7 @@ function useVoiceInput(options = {}) {
 				if (streaming && !sttRef.current) {
 					if (!shouldLoad) setShouldLoad(true);
 					setIsLoading(true);
-					const { WhisperSTT } = await import("../stt-KzSoNvwI.mjs");
+					const { WhisperSTT } = await import("../stt-BtklAjR2.js");
 					const stt = new WhisperSTT(model);
 					await stt.load({ onProgress: (p) => {
 						if (mountedRef.current) {
@@ -2061,7 +2171,7 @@ function useVoiceChat(options = {}) {
 				setIsLoading(true);
 				setError(null);
 				setLoadingMessage("Loading speech recognition (Whisper)...");
-				const { WhisperSTT } = await import("../stt-KzSoNvwI.mjs");
+				const { WhisperSTT } = await import("../stt-BtklAjR2.js");
 				if (cancelled || !mountedRef.current) return;
 				const stt = new WhisperSTT(sttModel);
 				await stt.load({ onProgress: (p) => {
@@ -2087,7 +2197,7 @@ function useVoiceChat(options = {}) {
 				}
 				llmWorkerRef.current = worker;
 				setLoadingMessage(`Loading text-to-speech (${ttsModelId === "supertonic-66m" ? "Supertonic" : "Kokoro"})...`);
-				const { createTTS } = await import("../tts-5yWeP_I0.mjs");
+				const { createTTS } = await import("../tts-DKIOWafo.js");
 				if (cancelled || !mountedRef.current) return;
 				const tts = createTTS(ttsModelId);
 				await tts.load({ onProgress: (p) => {
@@ -2378,4 +2488,4 @@ var browser_default = {
 
 //#endregion
 export { BUILTIN_MODELS, createAudioPlayer, createGerbilWorker, browser_default as default, getWebGPUInfo, isWebGPUSupported, playAudio, useChat, useCompletion, useSpeech, useVoiceChat, useVoiceInput };
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.js.map