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

package/README.md

@@ -5,15 +5,15 @@
 <h1 align="center">Gerbil</h1>
 
 <p align="center">
-  <strong>Local LLM inference for Node.js. GPU-accelerated. Zero config.</strong>
+  <strong>Local AI inference for Node.js. LLM, TTS, STT. GPU-accelerated. Zero config.</strong>
 </p>
 
 <p align="center">
   <a href="#install">Install</a> •
   <a href="#quick-start">Quick Start</a> •
-  <a href="#skills">Skills</a> •
+  <a href="#text-to-speech">TTS</a> •
+  <a href="#speech-to-text">STT</a> •
   <a href="./docs/ai-sdk.md">AI SDK</a> •
-  <a href="./docs/frameworks.md">Frameworks</a> •
   <a href="./docs/cli.md">CLI</a>
 </p>
 
@@ -45,6 +45,7 @@ const text = await gerbil("Explain recursion in one sentence");
 - **Zero Config** — `npx @tryhamster/gerbil "your prompt"` just works
 - **Local & Private** — No API keys, no data leaves your machine
 - **GPU Accelerated** — WebGPU with CPU fallback
+- **Complete Audio** — Text-to-Speech (Kokoro) & Speech-to-Text (Whisper)
 - **Framework Ready** — AI SDK v5, Next.js, Express, LangChain
 - **Skills System** — Built-in + custom skills with Zod validation
 - **Tool Calling** — Agentic capabilities with Qwen3 models
@@ -92,6 +93,55 @@ const data = await g.json("Extract: John, 32, NYC", {
 });
 ```
 
+## Text-to-Speech
+
+Generate natural speech locally using Kokoro TTS (28 voices):
+
+```typescript
+const result = await g.speak("Hello, I'm Gerbil!", { voice: "af_heart" });
+// result.audio = Float32Array, result.sampleRate = 24000
+
+// Stream long text
+for await (const chunk of g.speakStream("Long paragraph...")) {
+  // Play each chunk as it's generated
+}
+```
+
+```bash
+# CLI
+gerbil speak "Hello world" --voice bf_emma
+```
+
+📖 **[Full TTS Documentation →](./docs/tts.md)**
+
+## Speech-to-Text
+
+Transcribe audio locally using Whisper (7 models, 80+ languages):
+
+```typescript
+import { readFileSync } from "fs";
+
+const audio = new Uint8Array(readFileSync("recording.wav"));
+const result = await g.transcribe(audio);
+console.log(result.text);
+
+// With timestamps
+const result = await g.transcribe(audio, { timestamps: true });
+for (const seg of result.segments) {
+  console.log(`[${seg.start}s] ${seg.text}`);
+}
+
+// Record from microphone
+const result = await g.listen(5000); // 5 seconds
+```
+
+```bash
+# CLI
+gerbil transcribe audio.wav --timestamps
+```
+
+📖 **[Full STT Documentation →](./docs/stt.md)**
+
 ## Skills
 
 Built-in AI skills with Zod-validated inputs:
@@ -169,6 +219,8 @@ gerbil "Write a haiku"                        # Generate text
 gerbil commit                                 # Commit message from staged changes
 gerbil summarize README.md                    # Summarize file
 gerbil chat --thinking                        # Interactive chat
+gerbil speak "Hello world" --voice af_heart   # Text-to-speech
+gerbil transcribe audio.wav                   # Speech-to-text
 gerbil serve --mcp                            # MCP server for Claude/Cursor
 gerbil update                                 # Update to latest version
 ```
@@ -204,17 +256,19 @@ function Chat() {
 
 | Integration | Import | Docs |
 |-------------|--------|------|
-| **Browser** | `@tryhamster/gerbil/browser` | [📖 Browser Guide](./docs/browser.md) |
-| **AI SDK v5** | `@tryhamster/gerbil/ai` | [📖 AI SDK Guide](./docs/ai-sdk.md) |
+| **Browser** | `@tryhamster/gerbil/browser` | [📖 Browser](./docs/browser.md) |
+| **AI SDK v5** | `@tryhamster/gerbil/ai` | [📖 AI SDK](./docs/ai-sdk.md) |
 | **Next.js** | `@tryhamster/gerbil/next` | [📖 Frameworks](./docs/frameworks.md) |
 | **Express** | `@tryhamster/gerbil/express` | [📖 Frameworks](./docs/frameworks.md) |
-| **React** | `@tryhamster/gerbil/react` | [📖 Frameworks](./docs/frameworks.md) |
 | **LangChain** | `@tryhamster/gerbil/langchain` | [📖 Frameworks](./docs/frameworks.md) |
-| **MCP Server** | `npx @tryhamster/gerbil serve --mcp` | [📖 MCP Guide](./docs/mcp.md) |
-| **MCP Client** | `@tryhamster/gerbil/mcp-client` | [📖 MCP Client](./docs/mcp-client.md) |
+| **MCP Server** | `npx @tryhamster/gerbil serve --mcp` | [📖 MCP](./docs/mcp.md) |
+
+**Audio capabilities:** TTS and STT are built into the core `Gerbil` class, `@tryhamster/gerbil/browser` hooks, and `@tryhamster/gerbil/ai` provider.
 
 ## Models
 
+### Language Models
+
 | Model | Size | Best For |
 |-------|------|----------|
 | `qwen3-0.6b` | ~400MB | General use, reasoning (thinking mode) |
@@ -223,18 +277,29 @@ function Chat() {
 
 Use any HuggingFace model: `npx @tryhamster/gerbil -m hf:org/model "prompt"`
 
+### Audio Models
+
+| Model | Type | Size | Notes |
+|-------|------|------|-------|
+| `kokoro-82m` | TTS | ~330MB | 28 voices, English |
+| `whisper-tiny.en` | STT | 39MB | English, fastest |
+| `whisper-base.en` | STT | 74MB | English, balanced |
+| `whisper-small` | STT | 244MB | 80+ languages |
+
 ## Documentation
 
 | Guide | Description |
 |-------|-------------|
-| [📖 Browser](./docs/browser.md) | WebGPU inference in the browser |
-| [📖 Skills](./docs/skills.md) | Built-in skills, custom skill development, registry API |
-| [📖 Tools](./docs/tools.md) | Tool calling, agentic workflows, custom tools |
+| [📖 Text-to-Speech](./docs/tts.md) | Kokoro TTS, 28 voices, streaming audio |
+| [📖 Speech-to-Text](./docs/stt.md) | Whisper STT, transcription, voice input |
+| [📖 Browser](./docs/browser.md) | WebGPU inference, React hooks |
+| [📖 Skills](./docs/skills.md) | Built-in skills, custom skill development |
+| [📖 Tools](./docs/tools.md) | Tool calling, agentic workflows |
 | [📖 REPL](./docs/repl.md) | Interactive terminal dashboard |
-| [📖 AI SDK](./docs/ai-sdk.md) | Vercel AI SDK v5 integration |
-| [📖 Frameworks](./docs/frameworks.md) | Next.js, Express, React, Fastify, Hono, tRPC, LangChain |
+| [📖 AI SDK](./docs/ai-sdk.md) | Vercel AI SDK v5 (LLM, TTS, STT) |
+| [📖 Frameworks](./docs/frameworks.md) | Next.js, Express, React, LangChain |
 | [📖 CLI](./docs/cli.md) | All CLI commands and options |
-| [📖 MCP Server](./docs/mcp.md) | MCP server setup for Claude Desktop & Cursor |
+| [📖 MCP Server](./docs/mcp.md) | MCP server for Claude Desktop & Cursor |
 | [📖 MCP Client](./docs/mcp-client.md) | Connect to external MCP servers |
 
 ## Requirements

package/dist/auto-update-DsWBBnEk.mjs

@@ -0,0 +1,3 @@
+import { c as checkForUpdate, l as compareVersions, s as CURRENT_VERSION, u as installUpdate } from "./cli.mjs";
+
+export { CURRENT_VERSION, checkForUpdate, installUpdate };

package/dist/browser/index.d.mts

@@ -1,5 +1,5 @@
-import { _ as SystemInfo, a as GenerateOptions, c as GerbilModelSettings, d as LoadOptions, f as ModelConfig, g as SessionStats, h as ProgressInfo, i as FallbackConfig, l as GerbilProviderSettings, m as ModelStats, n as EmbedOptions, o as GenerateResult, p as ModelSource, r as EmbedResult, s as GerbilConfig, t as CacheConfig, u as JsonOptions } from "../types-BS1N92Jt.mjs";
-import { t as BUILTIN_MODELS } from "../models-De2-_GmQ.mjs";
+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";
 
 //#region src/browser/index.d.ts
 
@@ -55,6 +55,13 @@ type GenerateStreamOptions = {
   thinking?: boolean;
   /** System prompt */
   system?: string;
+  /** Image URLs or data URIs (for vision models) */
+  images?: string[];
+  /** Conversation history for multi-turn (includes all previous messages) */
+  history?: Array<{
+    role: "user" | "assistant" | "system";
+    content: string;
+  }>;
 };
 type GerbilWorker = {
   /** Generate text with streaming */
@@ -81,6 +88,8 @@ type Message = {
   role: "user" | "assistant";
   content: string;
   thinking?: string;
+  /** Attached images (URLs or data URIs) - for vision models */
+  images?: string[];
 };
 /** Loading progress state */
 type LoadingProgress = {
@@ -146,6 +155,16 @@ type UseChatReturn = {
   error: string | null;
   /** Load the model (only needed if lazy: true) */
   load: () => void;
+  /** Currently attached images (for next message) */
+  attachedImages: string[];
+  /** Attach an image to the next message */
+  attachImage: (imageUrl: string) => void;
+  /** Remove an attached image */
+  removeImage: (index: number) => void;
+  /** Clear all attached images */
+  clearImages: () => void;
+  /** Send message with specific images (convenience method) */
+  sendWithImages: (text: string, images: string[]) => void;
 };
 /**
  * React hook for chat with local LLM
@@ -193,14 +212,19 @@ type UseCompletionOptions = {
   /** Called on error */
   onError?: (error: string) => void;
 };
+/** Options for single completion call */
+type CompleteOptions = {
+  /** Image URLs or data URIs to analyze (for vision models) */
+  images?: string[];
+};
 /** Return type for useCompletion hook */
 type UseCompletionReturn = {
   /** Generated completion */
   completion: string;
   /** Thinking content (if enabled) */
   thinking: string;
-  /** Generate completion */
-  complete: (prompt: string) => Promise<string>;
+  /** Generate completion (optionally with images for vision models) */
+  complete: (prompt: string, options?: CompleteOptions) => Promise<string>;
   /** Whether model is loading */
   isLoading: boolean;
   /** Loading progress */
@@ -240,6 +264,376 @@ type UseCompletionReturn = {
  * ```
  */
 declare function useCompletion(options?: UseCompletionOptions): UseCompletionReturn;
+/** TTS loading progress */
+type TTSProgress = {
+  status: "idle" | "loading" | "downloading" | "ready" | "error";
+  message?: string;
+  file?: string;
+  progress?: number;
+  error?: string;
+};
+/** Available TTS models */
+type TTSModelId = "kokoro-82m" | "supertonic-66m";
+/** Voice info for TTS models */
+type BrowserVoiceInfo = {
+  id: string;
+  name: string;
+  gender: "male" | "female";
+  language: string;
+  description: string;
+};
+/** Options for useSpeech hook */
+type UseSpeechOptions = {
+  /** TTS model to use (default: "kokoro-82m") */
+  model?: TTSModelId;
+  /** Default voice ID (default: model's default voice) */
+  voice?: string;
+  /** Speech speed multiplier (default: 1.0) */
+  speed?: number;
+  /** Auto-load TTS model on mount (default: false) */
+  autoLoad?: boolean;
+  /** Called when model is ready */
+  onReady?: () => void;
+  /** Called on error */
+  onError?: (error: string) => void;
+  /** Called when speech starts */
+  onStart?: () => void;
+  /** Called when speech ends */
+  onEnd?: () => void;
+};
+/** Return type for useSpeech hook */
+type UseSpeechReturn = {
+  /** Speak text aloud */
+  speak: (text: string, options?: {
+    voice?: string;
+    speed?: number;
+  }) => Promise<void>;
+  /** Stop current speech */
+  stop: () => void;
+  /** Whether TTS model is loading */
+  isLoading: boolean;
+  /** Loading progress */
+  loadingProgress: TTSProgress | null;
+  /** Whether currently speaking */
+  isSpeaking: boolean;
+  /** Whether TTS model is ready */
+  isReady: boolean;
+  /** Load the TTS model */
+  load: () => void;
+  /** Error message if any */
+  error: string | null;
+  /** List available voices for current model */
+  listVoices: () => BrowserVoiceInfo[];
+  /** Current voice ID */
+  currentVoice: string;
+  /** Set current voice */
+  setVoice: (voiceId: string) => void;
+  /** Current speed */
+  currentSpeed: number;
+  /** Set speed */
+  setSpeed: (speed: number) => void;
+  /** Current TTS model ID */
+  currentModel: TTSModelId;
+  /** Sample rate for current model (24000 for Kokoro, 44100 for Supertonic) */
+  sampleRate: number;
+};
+/**
+ * React hook for text-to-speech with Web Audio API playback
+ *
+ * Supports both Kokoro (24kHz, high quality) and Supertonic (44.1kHz, faster).
+ *
+ * @example
+ * ```tsx
+ * import { useSpeech } from "@tryhamster/gerbil/browser";
+ *
+ * function App() {
+ *   // Default: Kokoro TTS
+ *   const { speak, stop, isLoading, isSpeaking, listVoices, setVoice } = useSpeech();
+ *
+ *   // Or use Supertonic (44.1kHz, faster)
+ *   // const { speak, listVoices } = useSpeech({ model: "supertonic-66m" });
+ *
+ *   if (isLoading) return <div>Loading TTS...</div>;
+ *
+ *   return (
+ *     <div>
+ *       <select onChange={e => setVoice(e.target.value)}>
+ *         {listVoices().map(v => (
+ *           <option key={v.id} value={v.id}>{v.name}</option>
+ *         ))}
+ *       </select>
+ *       <button onClick={() => speak("Hello world!")}>
+ *         {isSpeaking ? "Speaking..." : "Speak"}
+ *       </button>
+ *       {isSpeaking && <button onClick={stop}>Stop</button>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useSpeech(options?: UseSpeechOptions): UseSpeechReturn;
+/**
+ * Play audio from Float32Array using Web Audio API
+ *
+ * @example
+ * ```ts
+ * import { playAudio } from "@tryhamster/gerbil/browser";
+ *
+ * const audio = new Float32Array([...]); // TTS output
+ * const controller = await playAudio(audio, 24000);
+ *
+ * // Stop playback
+ * controller.stop();
+ * ```
+ */
+declare function playAudio(audio: Float32Array, sampleRate?: number): Promise<{
+  stop: () => void;
+  onEnded: Promise<void>;
+}>;
+/**
+ * Create a reusable audio player for streaming TTS
+ *
+ * @example
+ * ```ts
+ * import { createAudioPlayer } from "@tryhamster/gerbil/browser";
+ *
+ * const player = createAudioPlayer(24000);
+ *
+ * // Queue audio chunks as they arrive
+ * player.queue(chunk1);
+ * player.queue(chunk2);
+ *
+ * // Stop and clear
+ * player.stop();
+ * ```
+ */
+declare function createAudioPlayer(sampleRate?: number): {
+  queue: (audio: Float32Array) => void;
+  stop: () => void;
+  isPlaying: () => boolean;
+};
+/**
+ * Progress info for STT loading
+ */
+type STTProgress = {
+  status: "downloading" | "loading" | "ready" | "error";
+  message?: string;
+  progress?: number;
+  file?: string;
+};
+/**
+ * Options for useVoiceInput hook
+ */
+type UseVoiceInputOptions = {
+  /** STT model ID (default: whisper-tiny.en) */
+  model?: string;
+  /** Auto-load model on mount (default: false) */
+  autoLoad?: boolean;
+  /** Callback when model is ready */
+  onReady?: () => void;
+  /** Callback when transcription completes (or for each chunk in streaming mode) */
+  onTranscript?: (text: string) => void;
+  /** Callback on error */
+  onError?: (error: string) => void;
+  /** Callback during loading */
+  onProgress?: (progress: STTProgress) => void;
+  /** Enable streaming transcription - transcribes audio in chunks as you speak */
+  streaming?: boolean;
+  /** Chunk duration in ms for streaming mode (default: 3000 = 3 seconds) */
+  chunkDuration?: number;
+  /** Callback for each streaming chunk with partial transcript */
+  onChunk?: (text: string, chunkIndex: number) => void;
+};
+/**
+ * Return type for useVoiceInput hook
+ */
+type UseVoiceInputReturn = {
+  /** Start recording audio */
+  startRecording: () => Promise<void>;
+  /** Stop recording and transcribe */
+  stopRecording: () => Promise<string>;
+  /** Cancel recording without transcribing */
+  cancelRecording: () => void;
+  /** Transcribe raw audio data (Float32Array at 16kHz) */
+  transcribe: (audio: Float32Array) => Promise<string>;
+  /** Whether currently recording */
+  isRecording: boolean;
+  /** Whether transcribing */
+  isTranscribing: boolean;
+  /** Whether model is loading */
+  isLoading: boolean;
+  /** Whether model is ready */
+  isReady: boolean;
+  /** Latest transcription result (full transcript in streaming mode) */
+  transcript: string;
+  /** Current streaming chunk being transcribed (streaming mode only) */
+  streamingChunk: string;
+  /** Number of chunks transcribed so far (streaming mode only) */
+  chunkCount: number;
+  /** Loading progress */
+  loadingProgress: STTProgress | null;
+  /** Error message */
+  error: string | null;
+  /** Manually load the model */
+  load: () => void;
+};
+/**
+ * React hook for voice input with browser microphone
+ *
+ * Uses MediaRecorder to capture audio and Whisper for transcription.
+ * Supports both one-shot and streaming transcription modes.
+ *
+ * @example Basic usage (one-shot)
+ * ```tsx
+ * function VoiceInput() {
+ *   const { startRecording, stopRecording, isRecording, transcript } = useVoiceInput({
+ *     onTranscript: (text) => console.log("User said:", text),
+ *   });
+ *
+ *   return (
+ *     <button onClick={isRecording ? stopRecording : startRecording}>
+ *       {isRecording ? "Stop" : "Record"}
+ *     </button>
+ *   );
+ * }
+ * ```
+ *
+ * @example Streaming transcription (real-time)
+ * ```tsx
+ * function LiveTranscription() {
+ *   const { startRecording, stopRecording, isRecording, transcript, streamingChunk } = useVoiceInput({
+ *     streaming: true,           // Enable streaming mode
+ *     chunkDuration: 1500,       // Transcribe every 1.5 seconds (default)
+ *     onChunk: (text, idx) => console.log(`Chunk ${idx}: ${text}`),
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={isRecording ? stopRecording : startRecording}>
+ *         {isRecording ? "Stop" : "Start Live Transcription"}
+ *       </button>
+ *       <p>Current chunk: {streamingChunk}</p>
+ *       <p>Full transcript: {transcript}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useVoiceInput(options?: UseVoiceInputOptions): UseVoiceInputReturn;
+/**
+ * Options for useVoiceChat hook
+ */
+type UseVoiceChatOptions = {
+  /** LLM model ID (default: qwen3-0.6b) */
+  llmModel?: string;
+  /** STT model ID (default: whisper-tiny.en) */
+  sttModel?: string;
+  /** TTS model ID (default: kokoro-82m, also supports supertonic-66m) */
+  ttsModel?: TTSModelId;
+  /** System prompt for LLM */
+  system?: string;
+  /** Enable thinking mode (default: false) */
+  thinking?: boolean;
+  /** TTS voice ID (default: model's default voice) */
+  voice?: string;
+  /** TTS speech speed (default: 1.0) */
+  speed?: number;
+  /** Auto-load all models on mount (default: false) */
+  autoLoad?: boolean;
+  /** Callback when user speaks */
+  onUserSpeak?: (text: string) => void;
+  /** Callback when assistant responds */
+  onAssistantSpeak?: (text: string) => void;
+  /** Callback on error */
+  onError?: (error: string) => void;
+};
+/**
+ * Message in voice chat
+ */
+type VoiceChatMessage = {
+  id: string;
+  role: "user" | "assistant";
+  content: string;
+  thinking?: string;
+  audioUrl?: string;
+};
+/**
+ * Return type for useVoiceChat hook
+ */
+type UseVoiceChatReturn = {
+  /** Messages in the conversation */
+  messages: VoiceChatMessage[];
+  /** Start recording user speech */
+  startListening: () => Promise<void>;
+  /** Stop recording and process (STT → LLM → TTS) */
+  stopListening: () => Promise<void>;
+  /** Cancel current operation */
+  cancel: () => void;
+  /** Clear conversation history */
+  clear: () => void;
+  /** Whether recording user speech */
+  isListening: boolean;
+  /** Whether processing (STT/LLM/TTS) */
+  isProcessing: boolean;
+  /** Whether assistant is speaking */
+  isSpeaking: boolean;
+  /** Current stage: idle, listening, transcribing, thinking, speaking */
+  stage: "idle" | "listening" | "transcribing" | "thinking" | "speaking";
+  /** Whether all models are loaded */
+  isReady: boolean;
+  /** Whether loading models */
+  isLoading: boolean;
+  /** Loading progress message */
+  loadingMessage: string;
+  /** Error message */
+  error: string | null;
+  /** Manually load all models */
+  load: () => void;
+};
+/**
+ * React hook for voice conversation with STT + LLM + TTS
+ *
+ * Complete voice-to-voice conversation loop:
+ * 1. User presses button to speak
+ * 2. Speech is transcribed (Whisper)
+ * 3. LLM generates response
+ * 4. Response is spoken aloud (Kokoro or Supertonic TTS)
+ *
+ * @example
+ * ```tsx
+ * function VoiceChat() {
+ *   const {
+ *     messages,
+ *     startListening,
+ *     stopListening,
+ *     isListening,
+ *     isSpeaking,
+ *     stage,
+ *   } = useVoiceChat({
+ *     system: "You are a helpful voice assistant.",
+ *     voice: "af_bella",
+ *     // Or use Supertonic for faster synthesis:
+ *     // ttsModel: "supertonic-66m",
+ *     // voice: "F1",
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       {messages.map(m => (
+ *         <div key={m.id}>{m.role}: {m.content}</div>
+ *       ))}
+ *       <button
+ *         onMouseDown={startListening}
+ *         onMouseUp={stopListening}
+ *       >
+ *         {stage === "idle" ? "🎤 Hold to Speak" : stage}
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+declare function useVoiceChat(options?: UseVoiceChatOptions): UseVoiceChatReturn;
 /**
  * Check if WebGPU is supported
  */
@@ -256,7 +650,9 @@ declare const _default: {
   isWebGPUSupported: typeof isWebGPUSupported;
   getWebGPUInfo: typeof getWebGPUInfo;
   createGerbilWorker: typeof createGerbilWorker;
+  playAudio: typeof playAudio;
+  createAudioPlayer: typeof createAudioPlayer;
 };
 //#endregion
-export { BUILTIN_MODELS, CacheConfig, EmbedOptions, EmbedResult, FallbackConfig, GenerateOptions, GenerateResult, GenerateStreamOptions, GerbilConfig, GerbilModelSettings, GerbilProviderSettings, GerbilWorker, GerbilWorkerOptions, JsonOptions, LoadOptions, LoadingProgress, Message, ModelConfig, ModelSource, ModelStats, ProgressInfo, SessionStats, SystemInfo, UseChatOptions, UseChatReturn, UseCompletionOptions, UseCompletionReturn, WorkerComplete, WorkerProgress, WorkerToken, createGerbilWorker, _default as default, getWebGPUInfo, isWebGPUSupported, useChat, useCompletion };
+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

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/browser/index.ts"],"sourcesContent":[],"mappings":";;;;;KA6DY,cAAA;;;;;;;;;;;KAYA,WAAA;;;;;;;KAQA,cAAA;;;;;;;KAQA,mBAAA;;;;0BAIc;;oBAEN;;wBAEI;;;;;;KAOZ,qBAAA;;;;;;;;;;;;;;KAeA,YAAA;;uCAE2B,0BAA0B;;;;;;;;;;;;;;;;iBAqB3C,kBAAA,WAA4B,sBAA2B,QAAQ;;KAwTzE,OAAA;;;;;;;KAQA,eAAA;;;;;;;;;;;KAYA,cAAA;;;;;;;;;;;;oBAYQ;;;;;;;;;KAUR,aAAA;;YAEA;;;;;;;;;;;;mBAUO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6CH,OAAA,WAAiB,iBAAsB;;KAmQ3C,oBAAA;;;;;;;;;;;;;;;;;;;KAoBA,mBAAA;;;;;;gCAMoB;;;;mBAIb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCH,aAAA,WAAuB,uBAA4B;;;;iBAqMnD,iBAAA,CAAA;;;;iBAUM,aAAA,CAAA,GAAiB;;;;;cAwBtC"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/browser/index.ts"],"sourcesContent":[],"mappings":";;;;;AA0hEgB,KA79DJ,cAAA,GA69DqB;EAgErB,MAAA,EAAA,SAAW,GAAA,aAAA,GAAA,OAAA,GAAA,OAAA;EAUX,OAAA,CAAA,EAAA,MAAA;EAwBA,IAAA,CAAA,EAAA,MAAA;EAEY,QAAA,CAAA,EAAA,MAAA;EAED;EAID,aAAA,CAAA,EAAA,MAAA;EAAiB;EAgBpB,UAAA,CAAA,EAAA,MAAA;EAAW,KAAA,CAAA,EAAA,MAAA;AAiD9B,CAAA;AA2iBY,KAvqFA,WAAA,GAuqFmB;EA4BnB,MAAA,EAAA,OAAA;EAWA,IAAA,EAAA,MAAA;EAEA,KAAA,EAAA,UAAA,GAAA,WAAA;EAEY,SAAA,EAAA,MAAA;EAED,GAAA,EAAA,MAAA;CAAO;AAoEd,KAhxFJ,cAAA,GAgxFgB;EAgcZ,MAAA,EAAA,UAAA;EAUM,IAAA,EAAA,MAAA;EAwBrB,SAAA,EAAA,MAAA;;;;KA1uGW,mBAAA;;;;0BAIc;;oBAEN;;wBAEI;;;;;;KAOZ,qBAAA;;;;;;;;;;;;;;;;YAgBA;;;;;KAGA,YAAA;;uCAE2B,0BAA0B;;;;;;;;;;;;;;;;iBAqB3C,kBAAA,WAA4B,sBAA2B,QAAQ;;KA+ezE,OAAA;;;;;;;;;KAUA,eAAA;;;;;;;;;;;KAYA,cAAA;;;;;;;;;;;;oBAYQ;;;;;;;;;KAUR,aAAA;;YAEA;;;;;;;;;;;;mBAUO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDH,OAAA,WAAiB,iBAAsB;;KAwS3C,oBAAA;;;;;;;;;;;;;;;;;;;KAoBA,eAAA;;;;;KAMA,mBAAA;;;;;;uCAM2B,oBAAoB;;;;mBAIxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCH,aAAA,WAAuB,uBAA4B;;KAsMvD,WAAA;;;;;;;;KASA,UAAA;;KAGA,gBAAA;;;;;;;;KA0NA,gBAAA;;UAEF;;;;;;;;;;;;;;;;;KAkBE,eAAA;;;;;QAE6D;;;;;;mBAMtD;;;;;;;;;;oBAUC;;;;;;;;;;gBAUJ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuCA,SAAA,WAAmB,mBAAwB;;;;;;;;;;;;;;;iBAiYrC,SAAA,QACb,oCAEN;;WAAqC;;;;;;;;;;;;;;;;;;;iBAmDxB,iBAAA;iBACC;;;;;;;KA+DL,WAAA;;;;;;;;;KAUA,oBAAA;;;;;;;;;;;;0BAYc;;;;;;;;;;;KAYd,mBAAA;;wBAEY;;uBAED;;;;sBAID,iBAAiB;;;;;;;;;;;;;;;;mBAgBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiDH,aAAA,WAAuB,uBAA4B;;;;KA2iBvD,mBAAA;;;;;;aAMC;;;;;;;;;;;;;;;;;;;;;KAsBD,gBAAA;;;;;;;;;;KAWA,kBAAA;;YAEA;;wBAEY;;uBAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEP,YAAA,WAAsB,sBAA2B;;;;iBAgcjD,iBAAA,CAAA;;;;iBAUM,aAAA,CAAA,GAAiB;;;;;cAwBtC"}