Add Qwen3-TTS local bridge: ?tts= override + tts_server.py

LeLab-style: point the (hosted or local) UI at a self-run Qwen3-TTS server so voices
are designed on YOUR GPU, off the grid.

- ttsQwen3.js: endpoint is configurable via a ?tts=<base> query param (persisted to
localStorage; ?tts= clears it). Default stays the same-origin /qwen-tts (DashScope).
backendLabel shows 🖥 host when bridged.
- tts_server.py: standalone FastAPI server running the open weights
(Qwen3-TTS-12Hz-1.7B-VoiceDesign) via the qwen-tts package, POST /qwen-tts
{text,instruct,language} → WAV, CORS-open. QWEN_TTS_STUB=1 returns a tone so the
bridge can be smoke-tested without a GPU.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

.gitignore

@@ -1,2 +1,3 @@
 __pycache__/
 *.pyc
+.venv/

tts_server.py

@@ -0,0 +1,112 @@
+"""Local Qwen3-TTS Voice Design server — the LeLab-style bridge.
+
+Runs the OPEN WEIGHTS on YOUR machine's GPU; the hosted Tiny Army UI calls it via a
+`?tts=` override, so voices are designed locally and off the grid (no DashScope key/cost).
+
+Quick start (on a CUDA box; MPS/CPU work but are slow):
+
+    pip install qwen-tts soundfile "fastapi[standard]" uvicorn torch
+    python tts_server.py                      # serves http://localhost:8800/qwen-tts
+
+Then open the app pointed at this server:
+
+    http://localhost:7860/?tts=http://localhost:8800          # local UI + local TTS
+    https://tinyarmy.noods.cc/?tts=http://localhost:8800      # hosted UI + your GPU
+        (browsers block https→http://localhost by default; run Chrome with
+         --unsafely-treat-insecure-origin-as-secure=http://localhost:8800 or serve TLS)
+
+Smoke-test the bridge WITHOUT a GPU (returns a short tone instead of speech):
+
+    QWEN_TTS_STUB=1 python tts_server.py
+
+Env: PORT (8800), QWEN_TTS_MODEL (Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign), QWEN_TTS_STUB.
+"""
+import asyncio
+import io
+import math
+import os
+import struct
+
+from fastapi import FastAPI, Request
+from fastapi.responses import Response
+from fastapi.middleware.cors import CORSMiddleware
+
+MODEL_ID = os.environ.get("QWEN_TTS_MODEL", "Qwen/Qwen3-TTS-12Hz-1.7B-VoiceDesign")
+STUB = os.environ.get("QWEN_TTS_STUB", "") not in ("", "0", "false", "False")
+PORT = int(os.environ.get("PORT", "8800"))
+
+app = FastAPI()
+# The hosted UI is a different origin — allow it (and any localhost dev port).
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], allow_methods=["*"], allow_headers=["*"], allow_credentials=False,
+)
+
+_model = None
+_load_lock = asyncio.Lock()
+
+
+def _load_model():
+    global _model
+    if _model is not None:
+        return _model
+    import torch
+    from qwen_tts import Qwen3TTSModel
+    if torch.cuda.is_available():
+        dev, dtype = "cuda:0", torch.bfloat16
+    elif getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+        dev, dtype = "mps", torch.float32
+    else:
+        dev, dtype = "cpu", torch.float32
+    print(f"[tts] loading {MODEL_ID} on {dev} ({dtype})…", flush=True)
+    _model = Qwen3TTSModel.from_pretrained(MODEL_ID, device_map=dev, dtype=dtype)
+    print("[tts] model ready", flush=True)
+    return _model
+
+
+def _stub_wav(text, sr=24000):
+    """A short A4 tone — proves the bridge end-to-end without loading the model."""
+    secs = min(4.0, max(0.6, len(text) / 18.0))
+    n = int(sr * secs)
+    buf = io.BytesIO()
+    data = b"".join(struct.pack("<h", int(0.25 * 32767 * math.sin(2 * math.pi * 440 * i / sr))) for i in range(n))
+    buf.write(b"RIFF"); buf.write(struct.pack("<I", 36 + len(data))); buf.write(b"WAVE")
+    buf.write(b"fmt "); buf.write(struct.pack("<IHHIIHH", 16, 1, 1, sr, sr * 2, 2, 16))
+    buf.write(b"data"); buf.write(struct.pack("<I", len(data))); buf.write(data)
+    return buf.getvalue()
+
+
+def _synth(text, instruct, language):
+    if STUB:
+        return _stub_wav(text)
+    import soundfile as sf
+    wavs, sr = _load_model().generate_voice_design(text=text, language=language, instruct=instruct)
+    out = io.BytesIO(); sf.write(out, wavs[0], sr, format="WAV")
+    return out.getvalue()
+
+
+@app.get("/health")
+def health():
+    return {"ok": True, "model": MODEL_ID, "stub": STUB, "loaded": _model is not None}
+
+
+@app.post("/qwen-tts")
+async def qwen_tts(request: Request):
+    body = await request.json()
+    text = (body.get("text") or "").strip()
+    instruct = (body.get("instruct") or "").strip() or "A clear, natural voice at a moderate pace."
+    language = body.get("language") or "English"
+    if not text:
+        return Response("text required", status_code=400)
+    if not STUB:
+        async with _load_lock:  # one CPU/GPU model can't decode in parallel
+            wav = await asyncio.to_thread(_synth, text, instruct, language)
+    else:
+        wav = _synth(text, instruct, language)
+    return Response(wav, media_type="audio/wav", headers={"Cache-Control": "no-store"})
+
+
+if __name__ == "__main__":
+    import uvicorn
+    print(f"[tts] http://localhost:{PORT}/qwen-tts  (stub={STUB}, model={MODEL_ID})", flush=True)
+    uvicorn.run(app, host="0.0.0.0", port=PORT)

web/ttsQwen3.js

@@ -4,6 +4,22 @@
 // `voice_prompt`. NETWORKED — not local-first (clearly labeled). mode 'pcm'.
 import { decodeAudio } from '/web/ttsAudio.js'
 
+// Endpoint: default is our Space backend (/qwen-tts → DashScope). A `?tts=<base>` query
+// param (persisted to localStorage) points it at a self-run local server instead —
+// the LeLab-style bridge: hosted UI → Qwen3-TTS on YOUR GPU, off the grid. `?tts=`
+// (empty) clears the override. e.g. ?tts=http://localhost:8800
+const TTS_STORE = 'tinyarmy.ttsBase'
+function ttsBase() {
+  try {
+    const q = new URLSearchParams(location.search).get('tts')
+    if (q !== null) {
+      if (q) localStorage.setItem(TTS_STORE, q.replace(/\/+$/, ''))
+      else localStorage.removeItem(TTS_STORE)
+    }
+    return (localStorage.getItem(TTS_STORE) || '').replace(/\/+$/, '')
+  } catch { return '' }
+}
+
 // `desc()` returns the instruct string. 'persona' uses the dynamically-set description.
 let _desc = ''
 const VOICES = [
@@ -17,9 +33,9 @@ const get = (id) => VOICES.find((v) => v.id === id) || VOICES[0]
 
 async function synth(text, voiceId) {
   const instruct = (get(voiceId).desc() || '').trim()
-  const resp = await fetch('/qwen-tts', {
+  const resp = await fetch(`${ttsBase()}/qwen-tts`, {
     method: 'POST', headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ text, instruct }),
+    body: JSON.stringify({ text, instruct, language: 'English' }),
   })
   if (!resp.ok) throw new Error(`Qwen3-TTS ${resp.status}: ${(await resp.text()).slice(0, 140)}`)
   return decodeAudio(await resp.arrayBuffer())
@@ -36,6 +52,6 @@ export const engine = {
   defaultVoice: 'persona',
   ensure: async () => { /* nothing to load — server-side */ },
   synth,
-  backendLabel: () => '☁ DashScope',
+  backendLabel: () => { const b = ttsBase(); try { return b ? '🖥 ' + new URL(b).host : '☁ DashScope' } catch { return '☁ DashScope' } },
   setDesc(d) { _desc = (d || '').trim() },
 }