test: add evaluation coverage and pre-commit tooling

.husky/pre-commit

@@ -0,0 +1,4 @@
+bunx lint-staged
+bun run typecheck
+python3 -m pytest backend/tests/test_fixture_contract.py -q
+ruff check backend/tests/conftest.py backend/tests/test_generation_unload.py backend/tests/test_mcp_mount_slashes.py backend/tests/test_fixture_contract.py backend/tests/test_tts_vram_churn.py backend/tests/test_whisper_long_audio_e2e.py

.lintstagedrc

@@ -0,0 +1,3 @@
+{
+  "*": "prettier --ignore-unknown --write"
+}

.mcp.json

@@ -2,10 +2,10 @@
   "mcpServers": {
     "voicebox": {
       "type": "http",
-      "url": "http://127.0.0.1:17493/mcp",
+      "url": "http://127.0.0.1:17493/mcp/",
       "headers": {
         "X-Voicebox-Client-Id": "claude-code"
       }
     }
   }
-}
+}

.prettierrc

@@ -0,0 +1,9 @@
+{
+  "useTabs": false,
+  "tabWidth": 2,
+  "printWidth": 80,
+  "singleQuote": false,
+  "trailingComma": "es5",
+  "semi": true,
+  "arrowParens": "always"
+}

backend/app.py

@@ -129,7 +129,7 @@ def safe_content_disposition(disposition_type: str, filename: str) -> str:
 
 def create_app() -> FastAPI:
     """Create and configure the FastAPI application."""
-    from .mcp_server.server import build_mcp_server, compose_lifespan
+    from .mcp_server.server import MountRootSlashRewrite, build_mcp_server, compose_lifespan
     from .mcp_server.context import ClientIdMiddleware
 
     # Build the MCP app up-front so we can wire its lifespan into FastAPI's —
@@ -167,7 +167,7 @@ async def voicebox_lifespan(app: FastAPI):
     _configure_cors(application)
     application.add_middleware(ClientIdMiddleware)
     register_routers(application)
-    application.mount("/mcp", mcp_app)
+    application.mount("/mcp", MountRootSlashRewrite(mcp_app))
     logger.info("MCP: mounted at /mcp")
     _mount_frontend(application)
 

backend/backends/__init__.py

@@ -12,12 +12,15 @@
 # HF_HUB_OFFLINE=1 and on network failures.
 from ..utils import hf_offline_patch  # noqa: F401
 
+import logging
 import threading
 from dataclasses import dataclass, field
 from typing import Protocol, Optional, Tuple, List
 from typing_extensions import runtime_checkable
 import numpy as np
 
+logger = logging.getLogger(__name__)
+
 DEFAULT_LLM_MAX_TOKENS = 512
 DEFAULT_LLM_TEMPERATURE = 0.7
 
@@ -794,3 +797,45 @@ def reset_backends():
     _tts_backends.clear()
     _stt_backend = None
     _llm_backends.clear()
+
+
+def unload_all_models() -> None:
+    """Unload every registered backend and release accelerator caches.
+
+    Generation workers call this after each job so chained TTS, STT, and LLM
+    work cannot retain model weights indefinitely. Backend instances are
+    removed from the registry afterwards and recreated lazily on the next
+    request.
+    """
+    registered = [*_tts_backends.values(), *_llm_backends.values()]
+    if _stt_backend is not None:
+        registered.append(_stt_backend)
+    if _tts_backend is not None:
+        registered.append(_tts_backend)
+
+    # Keep the cleanup idempotent even if a legacy singleton points at an
+    # instance already present in one of the engine registries.
+    backends = list({id(backend): backend for backend in registered}.values())
+    for backend in backends:
+        try:
+            backend.unload_model()
+        except Exception:
+            logger.warning("Failed to unload backend %r", backend, exc_info=True)
+
+    reset_backends()
+
+    # Return cached blocks to the driver. torch is optional in MLX/CPU builds.
+    try:
+        import torch
+    except ImportError:
+        return
+    try:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+    except Exception:
+        logger.warning("Failed to empty CUDA cache", exc_info=True)
+    try:
+        if hasattr(torch, "mps") and torch.mps.is_available():
+            torch.mps.empty_cache()
+    except Exception:
+        logger.warning("Failed to empty MPS cache", exc_info=True)

backend/backends/pytorch_backend.py

@@ -296,7 +296,13 @@ def _load_model_sync(self, model_size: str):
             logger.info("Loading Whisper model %s on %s...", model_size, self.device)
 
             self.processor = WhisperProcessor.from_pretrained(model_name)
-            self.model = WhisperForConditionalGeneration.from_pretrained(model_name)
+            # Usar bfloat16 en lugar de float32 para ahorrar VRAM en GPUs
+            # modernas (RTX 40/50, Ada/Blackwell) sin incurrir en el bug de
+            # dtype de float16 (c10::Half) que se da en esta arquitectura.
+            self.model = WhisperForConditionalGeneration.from_pretrained(
+                model_name,
+                torch_dtype=torch.bfloat16,
+            )
 
         self.model.to(self.device)
         self.model_size = model_size
@@ -342,37 +348,59 @@ def _transcribe_sync():
             # state — forcing offline here (issue #462) broke online users
             # whose `get_decoder_prompt_ids` / tokenizer calls issue
             # legitimate metadata lookups.
-            # Process audio
-            inputs = self.processor(
-                audio,
-                sampling_rate=16000,
-                return_tensors="pt",
-            )
-            inputs = inputs.to(self.device)
+            # Whisper's encoder only accepts 30s of audio per pass (3000 mel
+            # frames); feeding it a longer clip silently transcribes just the
+            # first 30 seconds. Chunk into 30s windows and join the results.
+            chunk_samples = 30 * 16000
+            chunks = [
+                audio[i : i + chunk_samples]
+                for i in range(0, len(audio), chunk_samples)
+            ] or [audio]
 
             # Generate transcription
             # If language is provided, force it; otherwise let Whisper auto-detect
-            generate_kwargs = {}
+            generate_kwargs = {
+                # Sin timestamps, Whisper a veces emite <|endoftext|> tras la
+                # primera frase de una ventana y descarta el resto del audio.
+                # Forzar timestamps obliga al modelo a recorrer la ventana
+                # completa en cada chunk.
+                "return_timestamps": True,
+            }
             if language:
                 forced_decoder_ids = self.processor.get_decoder_prompt_ids(
                     language=language,
                     task="transcribe",
                 )
                 generate_kwargs["forced_decoder_ids"] = forced_decoder_ids
 
-            with torch.no_grad():
-                predicted_ids = self.model.generate(
-                    inputs["input_features"],
-                    **generate_kwargs,
+            transcriptions = []
+            for chunk in chunks:
+                # Process audio
+                inputs = self.processor(
+                    chunk,
+                    sampling_rate=16000,
+                    return_tensors="pt",
+                )
+                # Mover al device y convertir al mismo dtype que el modelo para
+                # evitar el error "Input type (float) and bias type (...) should be
+                # the same" en GPUs como la RTX 5060.
+                inputs = inputs.to(device=self.device, dtype=self.model.dtype)
+
+                with torch.no_grad():
+                    predicted_ids = self.model.generate(
+                        inputs["input_features"],
+                        **generate_kwargs,
+                    )
+
+                # Decode
+                transcriptions.append(
+                    self.processor.batch_decode(
+                        predicted_ids,
+                        skip_special_tokens=True,
+                    )[0]
                 )
 
-            # Decode
-            transcription = self.processor.batch_decode(
-                predicted_ids,
-                skip_special_tokens=True,
-            )[0]
-
-            return transcription.strip()
+            return " ".join(t.strip() for t in transcriptions).strip()
 
         # Run blocking transcription in thread pool
         return await asyncio.to_thread(_transcribe_sync)

backend/mcp_server/README.md

@@ -15,7 +15,7 @@ Preferred — direct HTTP:
 {
   "mcpServers": {
     "voicebox": {
-      "url": "http://127.0.0.1:17493/mcp",
+      "url": "http://127.0.0.1:17493/mcp/",
       "headers": { "X-Voicebox-Client-Id": "claude-code" }
     }
   }
@@ -41,18 +41,18 @@ Claude Code one-liner:
 ```
 claude mcp add voicebox \
   --transport http \
-  --url http://127.0.0.1:17493/mcp \
+  --url http://127.0.0.1:17493/mcp/ \
   --header "X-Voicebox-Client-Id: claude-code"
 ```
 
 ## Tools
 
-| Name | Purpose |
-|---|---|
-| `voicebox.speak`          | Speak text in a voice profile. Returns a generation id you can poll. |
-| `voicebox.transcribe`     | Whisper transcription of a base64 blob or an absolute local path. |
-| `voicebox.list_captures`  | Recent captures (dictation / recording / file) with transcripts. |
-| `voicebox.list_profiles`  | Available voice profiles (cloned + preset). |
+| Name                     | Purpose                                                              |
+| ------------------------ | -------------------------------------------------------------------- |
+| `voicebox.speak`         | Speak text in a voice profile. Returns a generation id you can poll. |
+| `voicebox.transcribe`    | Whisper transcription of a base64 blob or an absolute local path.    |
+| `voicebox.list_captures` | Recent captures (dictation / recording / file) with transcripts.     |
+| `voicebox.list_profiles` | Available voice profiles (cloned + preset).                          |
 
 All tools resolve voice profiles in this precedence:
 
@@ -66,7 +66,7 @@ Settings → MCP.
 ## Debug with MCP Inspector
 
 ```
-npx @modelcontextprotocol/inspector http://127.0.0.1:17493/mcp
+npx @modelcontextprotocol/inspector http://127.0.0.1:17493/mcp/
 ```
 
 Point it at the URL, hit "List tools," call `voicebox.list_profiles`

backend/mcp_server/server.py

@@ -9,11 +9,12 @@
 from __future__ import annotations
 
 import logging
-from contextlib import AsyncExitStack, asynccontextmanager
 from collections.abc import Callable
+from contextlib import AsyncExitStack, asynccontextmanager
 
 from fastapi import FastAPI
 from fastmcp import FastMCP
+from starlette.types import ASGIApp, Receive, Scope, Send
 
 from .context import ClientIdMiddleware
 from .tools import register_tools
@@ -22,6 +23,31 @@
 logger = logging.getLogger(__name__)
 
 
+class MountRootSlashRewrite:
+    """ASGI wrapper that maps the bare mount root onto FastMCP's ``/`` route.
+
+    Starlette's ``Mount`` strips the ``/mcp`` prefix, so ``POST /mcp`` (no
+    trailing slash) arrives inside the sub-application with ``path == ""``
+    and FastMCP's router — which only knows ``/`` — answers 405. Most MCP
+    clients (Claude Code, Cursor, …) point at the bare ``/mcp`` URL and do
+    not follow 307 redirects on POST, so we rewrite the empty path to ``/``
+    instead of redirecting.
+    """
+
+    def __init__(self, app: ASGIApp) -> None:
+        self.app = app
+
+    async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
+        if scope["type"] == "http" and scope.get("path") == "":
+            scope = dict(scope)
+            scope["path"] = "/"
+            # Keep path and raw_path coherent for ASGI routers that inspect
+            # both fields (Starlette normally supplies raw_path from the
+            # original request, e.g. b"/mcp").
+            scope["raw_path"] = b"/"
+        await self.app(scope, receive, send)
+
+
 def build_mcp_server() -> FastMCP:
     """Create the FastMCP instance with Voicebox tools registered."""
     mcp = FastMCP(
@@ -55,7 +81,7 @@ def mount_into(
     # by the time tool handlers execute. Starlette composes middlewares
     # outermost-first, so adding here on the parent app is correct.
     app.add_middleware(ClientIdMiddleware)
-    app.mount("/mcp", mcp_app)
+    app.mount("/mcp", MountRootSlashRewrite(mcp_app))
     app.state.mcp_lifespan = mcp_app.router.lifespan_context
     logger.info("MCP: mounted at /mcp (FastMCP %s)", getattr(mcp, "version", ""))
 

backend/services/generation.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import asyncio
+import logging
 import traceback
 from typing import Literal, Optional
 
@@ -25,6 +26,26 @@
 from ..database import get_db
 from ..utils.tasks import get_task_manager
 
+logger = logging.getLogger(__name__)
+
+#: tada degenerates on long inputs (produces ~1s of audio or hallucinated
+#: text), so its chunks are capped well below the global 800-char default.
+TADA_MAX_CHUNK_CHARS = 250
+
+
+def effective_max_chunk_chars(engine: str, requested: Optional[int]) -> Optional[int]:
+    """Resolve the chunk size used for long-text TTS splitting.
+
+    ``GenerationRequest.max_chunk_chars`` defaults to 800, so callers almost
+    never pass ``None``. For tada we force :data:`TADA_MAX_CHUNK_CHARS`
+    unless the caller explicitly asked for an even smaller chunk.
+
+    Returns the requested value unchanged for other engines.
+    """
+    if engine == "tada" and (requested is None or requested > TADA_MAX_CHUNK_CHARS):
+        return TADA_MAX_CHUNK_CHARS
+    return requested
+
 
 async def run_generation(
     *,
@@ -55,6 +76,8 @@ async def run_generation(
         load_engine_model,
     )
     from ..utils.chunked_tts import generate_chunked
+
+    max_chunk_chars = effective_max_chunk_chars(engine, max_chunk_chars)
     from ..utils.audio import has_tts_runaway, normalize_audio, save_audio, trim_tts_output
 
     task_manager = get_task_manager()
@@ -156,6 +179,14 @@ async def run_generation(
     finally:
         task_manager.complete_generation(generation_id)
         bg_db.close()
+        # Liberar TODA la VRAM tras cada generación (TTS + Whisper + LLM).
+        # Liberar solo el motor usado dejaba Whisper cargado y la GPU de 8 GB
+        # acababa en CUDA OOM al encadenar varias generaciones.
+        try:
+            from ..backends import unload_all_models
+            unload_all_models()
+        except Exception:
+            logger.warning("Failed to unload models after generation", exc_info=True)
 
 
 def _notify_speak_end(generation_id: str, *, status: str) -> None:
@@ -281,6 +312,8 @@ async def generate_audio_sync(
         load_engine_model,
     )
     from ..utils.chunked_tts import generate_chunked
+
+    max_chunk_chars = effective_max_chunk_chars(engine, max_chunk_chars)
     from ..utils.audio import has_tts_runaway, normalize_audio, trim_tts_output
     from . import tts
 
@@ -297,6 +330,13 @@ async def generate_audio_sync(
         )
     finally:
         bg_db.close()
+        # Unload TTS model to free VRAM after speak
+        try:
+            tts_backend = get_tts_backend_for_engine(engine)
+            if tts_backend.is_loaded():
+                tts_backend.unload_model()
+        except Exception:
+            logger.warning("Failed to unload TTS model after speak", exc_info=True)
 
     trim_fn = trim_tts_output if engine_needs_trim(engine) else None
     runaway_detector = has_tts_runaway if engine_retries_runaway(engine) else None