nodebench-mcp 2.17.0 → 2.18.0

package/dist/tools/voiceBridgeTools.js

@@ -235,90 +235,90 @@ function rateLatency(perceivedMs) {
 // ─── Scaffold templates ──────────────────────────────────────────────────────
 function getScaffoldWhisperEdge(includeVAD) {
     const vadCode = includeVAD
-        ? `
-import numpy as np
-
-def detect_voice_activity(audio_chunk: np.ndarray, threshold: float = 0.02) -> bool:
-    """Simple energy-based Voice Activity Detection."""
-    energy = np.sqrt(np.mean(audio_chunk.astype(np.float32) ** 2))
-    return energy > threshold
+        ? `
+import numpy as np
+
+def detect_voice_activity(audio_chunk: np.ndarray, threshold: float = 0.02) -> bool:
+    """Simple energy-based Voice Activity Detection."""
+    energy = np.sqrt(np.mean(audio_chunk.astype(np.float32) ** 2))
+    return energy > threshold
 `
         : "";
     const vadImport = includeVAD ? "from vad import detect_voice_activity\n" : "";
     const vadUsage = includeVAD
-        ? `
-            # Check for voice activity before sending to Whisper
-            if not detect_voice_activity(audio_data):
+        ? `
+            # Check for voice activity before sending to Whisper
+            if not detect_voice_activity(audio_data):
                 continue`
         : "";
     return {
         files: [
             {
                 path: "voice_bridge.py",
-                content: `"""Voice Bridge: Whisper STT + Edge TTS + WebSocket server."""
-import asyncio
-import json
-import tempfile
-import wave
-import whisper
-import edge_tts
-import websockets
-${vadImport}
-# Load Whisper model (use "tiny" or "base" for speed, "small" for accuracy)
-model = whisper.load_model("base")
-
-async def transcribe(audio_data: bytes) -> str:
-    """Transcribe audio bytes using Whisper."""
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
-        # Write raw PCM as WAV
-        with wave.open(f.name, "wb") as wf:
-            wf.setnchannels(1)
-            wf.setsampwidth(2)
-            wf.setframerate(16000)
-            wf.writeframes(audio_data)
-        result = model.transcribe(f.name, language="en")
-    return result["text"].strip()
-
-async def synthesize(text: str) -> bytes:
-    """Synthesize speech using Edge TTS."""
-    communicate = edge_tts.Communicate(text, voice="en-US-AriaNeural")
-    audio_chunks = []
-    async for chunk in communicate.stream():
-        if chunk["type"] == "audio":
-            audio_chunks.append(chunk["data"])
-    return b"".join(audio_chunks)
-
-async def handle_client(websocket):
-    """Handle a WebSocket client connection."""
-    print("Client connected")
-    try:
-        async for message in websocket:
-            if isinstance(message, bytes):${vadUsage}
-                # Transcribe speech to text
-                transcript = await transcribe(message)
-                print(f"User: {transcript}")
-
-                # TODO: Send transcript to your LLM and get response
-                llm_response = f"Echo: {transcript}"
-
-                # Synthesize response to speech
-                audio = await synthesize(llm_response)
-                await websocket.send(audio)
-            else:
-                # Handle text/control messages
-                data = json.loads(message)
-                if data.get("type") == "ping":
-                    await websocket.send(json.dumps({{"type": "pong"}}))
-    except websockets.exceptions.ConnectionClosed:
-        print("Client disconnected")
-
-async def main():
-    print("Voice Bridge starting on ws://localhost:8765")
-    async with websockets.serve(handle_client, "localhost", 8765):
-        await asyncio.Future()  # Run forever
-
-if __name__ == "__main__":
-    asyncio.run(main())
+                content: `"""Voice Bridge: Whisper STT + Edge TTS + WebSocket server."""
+import asyncio
+import json
+import tempfile
+import wave
+import whisper
+import edge_tts
+import websockets
+${vadImport}
+# Load Whisper model (use "tiny" or "base" for speed, "small" for accuracy)
+model = whisper.load_model("base")
+
+async def transcribe(audio_data: bytes) -> str:
+    """Transcribe audio bytes using Whisper."""
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
+        # Write raw PCM as WAV
+        with wave.open(f.name, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(2)
+            wf.setframerate(16000)
+            wf.writeframes(audio_data)
+        result = model.transcribe(f.name, language="en")
+    return result["text"].strip()
+
+async def synthesize(text: str) -> bytes:
+    """Synthesize speech using Edge TTS."""
+    communicate = edge_tts.Communicate(text, voice="en-US-AriaNeural")
+    audio_chunks = []
+    async for chunk in communicate.stream():
+        if chunk["type"] == "audio":
+            audio_chunks.append(chunk["data"])
+    return b"".join(audio_chunks)
+
+async def handle_client(websocket):
+    """Handle a WebSocket client connection."""
+    print("Client connected")
+    try:
+        async for message in websocket:
+            if isinstance(message, bytes):${vadUsage}
+                # Transcribe speech to text
+                transcript = await transcribe(message)
+                print(f"User: {transcript}")
+
+                # TODO: Send transcript to your LLM and get response
+                llm_response = f"Echo: {transcript}"
+
+                # Synthesize response to speech
+                audio = await synthesize(llm_response)
+                await websocket.send(audio)
+            else:
+                # Handle text/control messages
+                data = json.loads(message)
+                if data.get("type") == "ping":
+                    await websocket.send(json.dumps({{"type": "pong"}}))
+    except websockets.exceptions.ConnectionClosed:
+        print("Client disconnected")
+
+async def main():
+    print("Voice Bridge starting on ws://localhost:8765")
+    async with websockets.serve(handle_client, "localhost", 8765):
+        await asyncio.Future()  # Run forever
+
+if __name__ == "__main__":
+    asyncio.run(main())
 `,
                 description: "Main voice bridge server: Whisper STT + Edge TTS over WebSocket",
             },
@@ -333,10 +333,10 @@ if __name__ == "__main__":
                 : []),
             {
                 path: "requirements.txt",
-                content: `openai-whisper
-edge-tts
-websockets
-numpy
+                content: `openai-whisper
+edge-tts
+websockets
+numpy
 `,
                 description: "Python dependencies",
             },
@@ -353,88 +353,88 @@ numpy
 }
 function getScaffoldDeepgramCartesia(includeVAD) {
     const vadBlock = includeVAD
-        ? `
-// Simple energy-based VAD
-function detectVoiceActivity(samples: Float32Array, threshold = 0.02): boolean {
-  let energy = 0;
-  for (let i = 0; i < samples.length; i++) energy += samples[i] * samples[i];
-  return Math.sqrt(energy / samples.length) > threshold;
-}
+        ? `
+// Simple energy-based VAD
+function detectVoiceActivity(samples: Float32Array, threshold = 0.02): boolean {
+  let energy = 0;
+  for (let i = 0; i < samples.length; i++) energy += samples[i] * samples[i];
+  return Math.sqrt(energy / samples.length) > threshold;
+}
 `
         : "";
     return {
         files: [
             {
                 path: "src/voice-bridge.ts",
-                content: `/**
- * Voice Bridge: Deepgram STT + Cartesia TTS (TypeScript)
- *
- * Requires:
- *   DEEPGRAM_API_KEY — from https://console.deepgram.com
- *   CARTESIA_API_KEY — from https://play.cartesia.ai
- */
-import { createClient, LiveTranscriptionEvents } from "@deepgram/sdk";
-import Cartesia from "@cartesia/cartesia-js";
-import { WebSocketServer } from "ws";
-
-const deepgram = createClient(process.env.DEEPGRAM_API_KEY!);
-const cartesia = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY! });
-${vadBlock}
-const wss = new WebSocketServer({ port: 8765 });
-console.log("Voice Bridge listening on ws://localhost:8765");
-
-wss.on("connection", (ws) => {
-  console.log("Client connected");
-
-  // Set up Deepgram live transcription
-  const dgConn = deepgram.listen.live({
-    model: "nova-2",
-    language: "en",
-    smart_format: true,
-    interim_results: false,
-  });
-
-  dgConn.on(LiveTranscriptionEvents.Open, () => {
-    console.log("Deepgram connection open");
-  });
-
-  dgConn.on(LiveTranscriptionEvents.Transcript, async (data) => {
-    const transcript = data.channel?.alternatives?.[0]?.transcript;
-    if (!transcript) return;
-
-    console.log(\`User: \${transcript}\`);
-
-    // TODO: Send transcript to your LLM and get response
-    const llmResponse = \`Echo: \${transcript}\`;
-
-    // Synthesize with Cartesia (streaming)
-    const ttsResponse = await cartesia.tts.sse({
-      modelId: "sonic-english",
-      transcript: llmResponse,
-      voice: { mode: "id", id: "a0e99841-438c-4a64-b679-ae501e7d6091" },
-      output_format: { container: "raw", encoding: "pcm_s16le", sample_rate: 24000 },
-    });
-
-    for await (const chunk of ttsResponse) {
-      if (ws.readyState === ws.OPEN) {
-        ws.send(chunk);
-      }
-    }
-  });
-
-  dgConn.on(LiveTranscriptionEvents.Error, (err) => {
-    console.error("Deepgram error:", err);
-  });
-
-  ws.on("message", (data: Buffer) => {${includeVAD ? "\n    // VAD check\n    const samples = new Float32Array(data.buffer);\n    if (!detectVoiceActivity(samples)) return;\n" : ""}
-    dgConn.send(data);
-  });
-
-  ws.on("close", () => {
-    dgConn.finish();
-    console.log("Client disconnected");
-  });
-});
+                content: `/**
+ * Voice Bridge: Deepgram STT + Cartesia TTS (TypeScript)
+ *
+ * Requires:
+ *   DEEPGRAM_API_KEY — from https://console.deepgram.com
+ *   CARTESIA_API_KEY — from https://play.cartesia.ai
+ */
+import { createClient, LiveTranscriptionEvents } from "@deepgram/sdk";
+import Cartesia from "@cartesia/cartesia-js";
+import { WebSocketServer } from "ws";
+
+const deepgram = createClient(process.env.DEEPGRAM_API_KEY!);
+const cartesia = new Cartesia({ apiKey: process.env.CARTESIA_API_KEY! });
+${vadBlock}
+const wss = new WebSocketServer({ port: 8765 });
+console.log("Voice Bridge listening on ws://localhost:8765");
+
+wss.on("connection", (ws) => {
+  console.log("Client connected");
+
+  // Set up Deepgram live transcription
+  const dgConn = deepgram.listen.live({
+    model: "nova-2",
+    language: "en",
+    smart_format: true,
+    interim_results: false,
+  });
+
+  dgConn.on(LiveTranscriptionEvents.Open, () => {
+    console.log("Deepgram connection open");
+  });
+
+  dgConn.on(LiveTranscriptionEvents.Transcript, async (data) => {
+    const transcript = data.channel?.alternatives?.[0]?.transcript;
+    if (!transcript) return;
+
+    console.log(\`User: \${transcript}\`);
+
+    // TODO: Send transcript to your LLM and get response
+    const llmResponse = \`Echo: \${transcript}\`;
+
+    // Synthesize with Cartesia (streaming)
+    const ttsResponse = await cartesia.tts.sse({
+      modelId: "sonic-english",
+      transcript: llmResponse,
+      voice: { mode: "id", id: "a0e99841-438c-4a64-b679-ae501e7d6091" },
+      output_format: { container: "raw", encoding: "pcm_s16le", sample_rate: 24000 },
+    });
+
+    for await (const chunk of ttsResponse) {
+      if (ws.readyState === ws.OPEN) {
+        ws.send(chunk);
+      }
+    }
+  });
+
+  dgConn.on(LiveTranscriptionEvents.Error, (err) => {
+    console.error("Deepgram error:", err);
+  });
+
+  ws.on("message", (data: Buffer) => {${includeVAD ? "\n    // VAD check\n    const samples = new Float32Array(data.buffer);\n    if (!detectVoiceActivity(samples)) return;\n" : ""}
+    dgConn.send(data);
+  });
+
+  ws.on("close", () => {
+    dgConn.finish();
+    console.log("Client disconnected");
+  });
+});
 `,
                 description: "TypeScript voice bridge: Deepgram Nova-2 STT + Cartesia Sonic streaming TTS",
             },
@@ -469,111 +469,111 @@ function getScaffoldBrowserWebspeech() {
         files: [
             {
                 path: "index.html",
-                content: `<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>Voice Bridge — Web Speech API</title>
-  <style>
-    body { font-family: system-ui, sans-serif; max-width: 600px; margin: 2rem auto; padding: 0 1rem; }
-    #status { padding: 0.5rem; border-radius: 4px; margin: 1rem 0; }
-    .listening { background: #dcfce7; color: #166534; }
-    .speaking { background: #dbeafe; color: #1e40af; }
-    .idle { background: #f3f4f6; color: #374151; }
-    #transcript { white-space: pre-wrap; border: 1px solid #d1d5db; padding: 1rem; border-radius: 4px; min-height: 200px; max-height: 400px; overflow-y: auto; }
-    button { padding: 0.75rem 1.5rem; font-size: 1rem; border: none; border-radius: 4px; cursor: pointer; margin: 0.25rem; }
-    #startBtn { background: #2563eb; color: white; }
-    #startBtn:disabled { background: #93c5fd; cursor: not-allowed; }
-    #stopBtn { background: #dc2626; color: white; }
-  </style>
-</head>
-<body>
-  <h1>Voice Bridge</h1>
-  <p>Browser-native STT + TTS using the Web Speech API. No server needed.</p>
-  <div>
-    <button id="startBtn" onclick="startListening()">Start Listening</button>
-    <button id="stopBtn" onclick="stopListening()">Stop</button>
-  </div>
-  <div id="status" class="idle">Idle</div>
-  <div id="transcript"></div>
-
-  <script>
-    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
-    if (!SpeechRecognition) {
-      document.getElementById("status").textContent = "Web Speech API not supported in this browser.";
-    }
-
-    const recognition = new SpeechRecognition();
-    recognition.continuous = true;
-    recognition.interimResults = true;
-    recognition.lang = "en-US";
-
-    const synth = window.speechSynthesis;
-    const transcriptEl = document.getElementById("transcript");
-    const statusEl = document.getElementById("status");
-    let isListening = false;
-
-    function setStatus(text, cls) {
-      statusEl.textContent = text;
-      statusEl.className = cls;
-    }
-
-    function appendTranscript(role, text) {
-      transcriptEl.textContent += role + ": " + text + "\\n";
-      transcriptEl.scrollTop = transcriptEl.scrollHeight;
-    }
-
-    recognition.onresult = (event) => {
-      const last = event.results[event.results.length - 1];
-      if (last.isFinal) {
-        const transcript = last[0].transcript.trim();
-        if (!transcript) return;
-
-        appendTranscript("You", transcript);
-        setStatus("Processing...", "speaking");
-
-        // TODO: Send transcript to your LLM API and get response
-        const llmResponse = "Echo: " + transcript;
-
-        appendTranscript("Assistant", llmResponse);
-
-        // Speak the response
-        const utterance = new SpeechSynthesisUtterance(llmResponse);
-        utterance.onstart = () => setStatus("Speaking...", "speaking");
-        utterance.onend = () => setStatus("Listening...", "listening");
-        synth.speak(utterance);
-      }
-    };
-
-    recognition.onerror = (event) => {
-      console.error("Speech recognition error:", event.error);
-      if (event.error !== "no-speech") {
-        setStatus("Error: " + event.error, "idle");
-      }
-    };
-
-    recognition.onend = () => {
-      if (isListening) recognition.start(); // Auto-restart
-    };
-
-    function startListening() {
-      isListening = true;
-      recognition.start();
-      setStatus("Listening...", "listening");
-      document.getElementById("startBtn").disabled = true;
-    }
-
-    function stopListening() {
-      isListening = false;
-      recognition.stop();
-      synth.cancel();
-      setStatus("Idle", "idle");
-      document.getElementById("startBtn").disabled = false;
-    }
-  </script>
-</body>
-</html>
+                content: `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>Voice Bridge — Web Speech API</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 600px; margin: 2rem auto; padding: 0 1rem; }
+    #status { padding: 0.5rem; border-radius: 4px; margin: 1rem 0; }
+    .listening { background: #dcfce7; color: #166534; }
+    .speaking { background: #dbeafe; color: #1e40af; }
+    .idle { background: #f3f4f6; color: #374151; }
+    #transcript { white-space: pre-wrap; border: 1px solid #d1d5db; padding: 1rem; border-radius: 4px; min-height: 200px; max-height: 400px; overflow-y: auto; }
+    button { padding: 0.75rem 1.5rem; font-size: 1rem; border: none; border-radius: 4px; cursor: pointer; margin: 0.25rem; }
+    #startBtn { background: #2563eb; color: white; }
+    #startBtn:disabled { background: #93c5fd; cursor: not-allowed; }
+    #stopBtn { background: #dc2626; color: white; }
+  </style>
+</head>
+<body>
+  <h1>Voice Bridge</h1>
+  <p>Browser-native STT + TTS using the Web Speech API. No server needed.</p>
+  <div>
+    <button id="startBtn" onclick="startListening()">Start Listening</button>
+    <button id="stopBtn" onclick="stopListening()">Stop</button>
+  </div>
+  <div id="status" class="idle">Idle</div>
+  <div id="transcript"></div>
+
+  <script>
+    const SpeechRecognition = window.SpeechRecognition || window.webkitSpeechRecognition;
+    if (!SpeechRecognition) {
+      document.getElementById("status").textContent = "Web Speech API not supported in this browser.";
+    }
+
+    const recognition = new SpeechRecognition();
+    recognition.continuous = true;
+    recognition.interimResults = true;
+    recognition.lang = "en-US";
+
+    const synth = window.speechSynthesis;
+    const transcriptEl = document.getElementById("transcript");
+    const statusEl = document.getElementById("status");
+    let isListening = false;
+
+    function setStatus(text, cls) {
+      statusEl.textContent = text;
+      statusEl.className = cls;
+    }
+
+    function appendTranscript(role, text) {
+      transcriptEl.textContent += role + ": " + text + "\\n";
+      transcriptEl.scrollTop = transcriptEl.scrollHeight;
+    }
+
+    recognition.onresult = (event) => {
+      const last = event.results[event.results.length - 1];
+      if (last.isFinal) {
+        const transcript = last[0].transcript.trim();
+        if (!transcript) return;
+
+        appendTranscript("You", transcript);
+        setStatus("Processing...", "speaking");
+
+        // TODO: Send transcript to your LLM API and get response
+        const llmResponse = "Echo: " + transcript;
+
+        appendTranscript("Assistant", llmResponse);
+
+        // Speak the response
+        const utterance = new SpeechSynthesisUtterance(llmResponse);
+        utterance.onstart = () => setStatus("Speaking...", "speaking");
+        utterance.onend = () => setStatus("Listening...", "listening");
+        synth.speak(utterance);
+      }
+    };
+
+    recognition.onerror = (event) => {
+      console.error("Speech recognition error:", event.error);
+      if (event.error !== "no-speech") {
+        setStatus("Error: " + event.error, "idle");
+      }
+    };
+
+    recognition.onend = () => {
+      if (isListening) recognition.start(); // Auto-restart
+    };
+
+    function startListening() {
+      isListening = true;
+      recognition.start();
+      setStatus("Listening...", "listening");
+      document.getElementById("startBtn").disabled = true;
+    }
+
+    function stopListening() {
+      isListening = false;
+      recognition.stop();
+      synth.cancel();
+      setStatus("Idle", "idle");
+      document.getElementById("startBtn").disabled = false;
+    }
+  </script>
+</body>
+</html>
 `,
                 description: "Self-contained HTML page using Web Speech API for both STT and TTS",
             },
@@ -589,97 +589,97 @@ function getScaffoldBrowserWebspeech() {
 }
 function getScaffoldWhisperPiper(includeVAD) {
     const vadCode = includeVAD
-        ? `
-import numpy as np
-
-def detect_voice_activity(audio_chunk: np.ndarray, threshold: float = 0.02) -> bool:
-    """Simple energy-based Voice Activity Detection."""
-    energy = np.sqrt(np.mean(audio_chunk.astype(np.float32) ** 2))
-    return energy > threshold
+        ? `
+import numpy as np
+
+def detect_voice_activity(audio_chunk: np.ndarray, threshold: float = 0.02) -> bool:
+    """Simple energy-based Voice Activity Detection."""
+    energy = np.sqrt(np.mean(audio_chunk.astype(np.float32) ** 2))
+    return energy > threshold
 `
         : "";
     const vadImport = includeVAD ? "from vad import detect_voice_activity\n" : "";
     const vadUsage = includeVAD
-        ? `
-            # Check for voice activity
-            if not detect_voice_activity(audio_data):
+        ? `
+            # Check for voice activity
+            if not detect_voice_activity(audio_data):
                 continue`
         : "";
     return {
         files: [
             {
                 path: "voice_bridge.py",
-                content: `"""Fully Local Voice Bridge: Whisper STT + Piper TTS. No cloud dependencies."""
-import asyncio
-import json
-import subprocess
-import tempfile
-import wave
-import whisper
-import websockets
-${vadImport}
-# Load Whisper model
-model = whisper.load_model("base")
-
-# Piper TTS configuration
-PIPER_MODEL = "en_US-lessac-medium"  # Download from https://github.com/rhasspy/piper/releases
-PIPER_BIN = "piper"  # Ensure piper is on PATH
-
-async def transcribe(audio_data: bytes) -> str:
-    """Transcribe audio bytes using Whisper."""
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
-        with wave.open(f.name, "wb") as wf:
-            wf.setnchannels(1)
-            wf.setsampwidth(2)
-            wf.setframerate(16000)
-            wf.writeframes(audio_data)
-        result = model.transcribe(f.name, language="en")
-    return result["text"].strip()
-
-async def synthesize(text: str) -> bytes:
-    """Synthesize speech using Piper TTS (local, ONNX-based)."""
-    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
-        proc = await asyncio.create_subprocess_exec(
-            PIPER_BIN,
-            "--model", PIPER_MODEL,
-            "--output_file", f.name,
-            stdin=asyncio.subprocess.PIPE,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        await proc.communicate(input=text.encode("utf-8"))
-        with open(f.name, "rb") as audio:
-            return audio.read()
-
-async def handle_client(websocket):
-    """Handle a WebSocket client connection."""
-    print("Client connected")
-    try:
-        async for message in websocket:
-            if isinstance(message, bytes):${vadUsage}
-                transcript = await transcribe(message)
-                print(f"User: {transcript}")
-
-                # TODO: Send to local LLM (e.g. llama.cpp server)
-                llm_response = f"Echo: {transcript}"
-
-                audio = await synthesize(llm_response)
-                await websocket.send(audio)
-            else:
-                data = json.loads(message)
-                if data.get("type") == "ping":
-                    await websocket.send(json.dumps({{"type": "pong"}}))
-    except websockets.exceptions.ConnectionClosed:
-        print("Client disconnected")
-
-async def main():
-    print("Local Voice Bridge starting on ws://localhost:8765")
-    print("Fully offline — no cloud APIs used.")
-    async with websockets.serve(handle_client, "localhost", 8765):
-        await asyncio.Future()
-
-if __name__ == "__main__":
-    asyncio.run(main())
+                content: `"""Fully Local Voice Bridge: Whisper STT + Piper TTS. No cloud dependencies."""
+import asyncio
+import json
+import subprocess
+import tempfile
+import wave
+import whisper
+import websockets
+${vadImport}
+# Load Whisper model
+model = whisper.load_model("base")
+
+# Piper TTS configuration
+PIPER_MODEL = "en_US-lessac-medium"  # Download from https://github.com/rhasspy/piper/releases
+PIPER_BIN = "piper"  # Ensure piper is on PATH
+
+async def transcribe(audio_data: bytes) -> str:
+    """Transcribe audio bytes using Whisper."""
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
+        with wave.open(f.name, "wb") as wf:
+            wf.setnchannels(1)
+            wf.setsampwidth(2)
+            wf.setframerate(16000)
+            wf.writeframes(audio_data)
+        result = model.transcribe(f.name, language="en")
+    return result["text"].strip()
+
+async def synthesize(text: str) -> bytes:
+    """Synthesize speech using Piper TTS (local, ONNX-based)."""
+    with tempfile.NamedTemporaryFile(suffix=".wav", delete=True) as f:
+        proc = await asyncio.create_subprocess_exec(
+            PIPER_BIN,
+            "--model", PIPER_MODEL,
+            "--output_file", f.name,
+            stdin=asyncio.subprocess.PIPE,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.communicate(input=text.encode("utf-8"))
+        with open(f.name, "rb") as audio:
+            return audio.read()
+
+async def handle_client(websocket):
+    """Handle a WebSocket client connection."""
+    print("Client connected")
+    try:
+        async for message in websocket:
+            if isinstance(message, bytes):${vadUsage}
+                transcript = await transcribe(message)
+                print(f"User: {transcript}")
+
+                # TODO: Send to local LLM (e.g. llama.cpp server)
+                llm_response = f"Echo: {transcript}"
+
+                audio = await synthesize(llm_response)
+                await websocket.send(audio)
+            else:
+                data = json.loads(message)
+                if data.get("type") == "ping":
+                    await websocket.send(json.dumps({{"type": "pong"}}))
+    except websockets.exceptions.ConnectionClosed:
+        print("Client disconnected")
+
+async def main():
+    print("Local Voice Bridge starting on ws://localhost:8765")
+    print("Fully offline — no cloud APIs used.")
+    async with websockets.serve(handle_client, "localhost", 8765):
+        await asyncio.Future()
+
+if __name__ == "__main__":
+    asyncio.run(main())
 `,
                 description: "Fully local voice bridge: Whisper + Piper (no cloud dependencies)",
             },
@@ -694,9 +694,9 @@ if __name__ == "__main__":
                 : []),
             {
                 path: "requirements.txt",
-                content: `openai-whisper
-websockets
-numpy
+                content: `openai-whisper
+websockets
+numpy
 `,
                 description: "Python dependencies (Piper installed separately as binary)",
             },
@@ -715,91 +715,91 @@ numpy
 function getScaffoldCustom(language, includeVAD) {
     if (language === "python") {
         const vadBlock = includeVAD
-            ? `
-class SimpleVAD:
-    """Energy-based Voice Activity Detection."""
-    def __init__(self, threshold: float = 0.02):
-        self.threshold = threshold
-
-    def is_speech(self, audio_chunk) -> bool:
-        import numpy as np
-        energy = np.sqrt(np.mean(np.frombuffer(audio_chunk, dtype=np.int16).astype(np.float32) ** 2))
-        return energy > self.threshold
+            ? `
+class SimpleVAD:
+    """Energy-based Voice Activity Detection."""
+    def __init__(self, threshold: float = 0.02):
+        self.threshold = threshold
+
+    def is_speech(self, audio_chunk) -> bool:
+        import numpy as np
+        energy = np.sqrt(np.mean(np.frombuffer(audio_chunk, dtype=np.int16).astype(np.float32) ** 2))
+        return energy > self.threshold
 `
             : "";
         return {
             files: [
                 {
                     path: "voice_bridge.py",
-                    content: `"""Custom Voice Bridge Template — Plug in any STT/TTS/LLM."""
-import asyncio
-import json
-from abc import ABC, abstractmethod
-import websockets
-
-
-class STTProvider(ABC):
-    @abstractmethod
-    async def transcribe(self, audio_data: bytes) -> str: ...
-
-class TTSProvider(ABC):
-    @abstractmethod
-    async def synthesize(self, text: str) -> bytes: ...
-
-class LLMProvider(ABC):
-    @abstractmethod
-    async def generate(self, prompt: str, history: list[dict]) -> str: ...
-${vadBlock}
-
-# ─── Implement your providers here ────────────────────────────────
-
-class MySTT(STTProvider):
-    async def transcribe(self, audio_data: bytes) -> str:
-        # TODO: Replace with your STT implementation
-        raise NotImplementedError("Implement STT provider")
-
-class MyTTS(TTSProvider):
-    async def synthesize(self, text: str) -> bytes:
-        # TODO: Replace with your TTS implementation
-        raise NotImplementedError("Implement TTS provider")
-
-class MyLLM(LLMProvider):
-    async def generate(self, prompt: str, history: list[dict]) -> str:
-        # TODO: Replace with your LLM implementation
-        return f"Echo: {prompt}"
-
-
-# ─── Voice bridge server ──────────────────────────────────────────
-
-class VoiceBridge:
-    def __init__(self, stt: STTProvider, tts: TTSProvider, llm: LLMProvider):
-        self.stt = stt
-        self.tts = tts
-        self.llm = llm
-
-    async def handle_client(self, websocket):
-        history = []
-        async for message in websocket:
-            if isinstance(message, bytes):
-                transcript = await self.stt.transcribe(message)
-                history.append({"role": "user", "content": transcript})
-                response = await self.llm.generate(transcript, history)
-                history.append({"role": "assistant", "content": response})
-                audio = await self.tts.synthesize(response)
-                await websocket.send(audio)
-            else:
-                data = json.loads(message)
-                await websocket.send(json.dumps({"type": "pong"}))
-
-    async def start(self, host: str = "localhost", port: int = 8765):
-        print(f"Voice Bridge on ws://{host}:{port}")
-        async with websockets.serve(self.handle_client, host, port):
-            await asyncio.Future()
-
-
-if __name__ == "__main__":
-    bridge = VoiceBridge(stt=MySTT(), tts=MyTTS(), llm=MyLLM())
-    asyncio.run(bridge.start())
+                    content: `"""Custom Voice Bridge Template — Plug in any STT/TTS/LLM."""
+import asyncio
+import json
+from abc import ABC, abstractmethod
+import websockets
+
+
+class STTProvider(ABC):
+    @abstractmethod
+    async def transcribe(self, audio_data: bytes) -> str: ...
+
+class TTSProvider(ABC):
+    @abstractmethod
+    async def synthesize(self, text: str) -> bytes: ...
+
+class LLMProvider(ABC):
+    @abstractmethod
+    async def generate(self, prompt: str, history: list[dict]) -> str: ...
+${vadBlock}
+
+# ─── Implement your providers here ────────────────────────────────
+
+class MySTT(STTProvider):
+    async def transcribe(self, audio_data: bytes) -> str:
+        # TODO: Replace with your STT implementation
+        raise NotImplementedError("Implement STT provider")
+
+class MyTTS(TTSProvider):
+    async def synthesize(self, text: str) -> bytes:
+        # TODO: Replace with your TTS implementation
+        raise NotImplementedError("Implement TTS provider")
+
+class MyLLM(LLMProvider):
+    async def generate(self, prompt: str, history: list[dict]) -> str:
+        # TODO: Replace with your LLM implementation
+        return f"Echo: {prompt}"
+
+
+# ─── Voice bridge server ──────────────────────────────────────────
+
+class VoiceBridge:
+    def __init__(self, stt: STTProvider, tts: TTSProvider, llm: LLMProvider):
+        self.stt = stt
+        self.tts = tts
+        self.llm = llm
+
+    async def handle_client(self, websocket):
+        history = []
+        async for message in websocket:
+            if isinstance(message, bytes):
+                transcript = await self.stt.transcribe(message)
+                history.append({"role": "user", "content": transcript})
+                response = await self.llm.generate(transcript, history)
+                history.append({"role": "assistant", "content": response})
+                audio = await self.tts.synthesize(response)
+                await websocket.send(audio)
+            else:
+                data = json.loads(message)
+                await websocket.send(json.dumps({"type": "pong"}))
+
+    async def start(self, host: str = "localhost", port: int = 8765):
+        print(f"Voice Bridge on ws://{host}:{port}")
+        async with websockets.serve(self.handle_client, host, port):
+            await asyncio.Future()
+
+
+if __name__ == "__main__":
+    bridge = VoiceBridge(stt=MySTT(), tts=MyTTS(), llm=MyLLM())
+    asyncio.run(bridge.start())
 `,
                     description: "Pluggable voice bridge template with abstract STT/TTS/LLM interfaces",
                 },
@@ -814,88 +814,88 @@ if __name__ == "__main__":
     }
     // TypeScript custom template
     const vadBlock = includeVAD
-        ? `
-/** Simple energy-based Voice Activity Detection. */
-function detectVoiceActivity(samples: Float32Array, threshold = 0.02): boolean {
-  let energy = 0;
-  for (let i = 0; i < samples.length; i++) energy += samples[i] * samples[i];
-  return Math.sqrt(energy / samples.length) > threshold;
-}
+        ? `
+/** Simple energy-based Voice Activity Detection. */
+function detectVoiceActivity(samples: Float32Array, threshold = 0.02): boolean {
+  let energy = 0;
+  for (let i = 0; i < samples.length; i++) energy += samples[i] * samples[i];
+  return Math.sqrt(energy / samples.length) > threshold;
+}
 `
         : "";
     return {
         files: [
             {
                 path: "src/voice-bridge.ts",
-                content: `/**
- * Custom Voice Bridge Template — Plug in any STT/TTS/LLM.
- */
-import { WebSocketServer } from "ws";
-
-// ─── Provider interfaces ─────────────────────────────────────────
-
-interface STTProvider {
-  transcribe(audio: Buffer): Promise<string>;
-}
-
-interface TTSProvider {
-  synthesize(text: string): Promise<Buffer>;
-}
-
-interface LLMProvider {
-  generate(prompt: string, history: Array<{ role: string; content: string }>): Promise<string>;
-}
-${vadBlock}
-// ─── Implement your providers here ───────────────────────────────
-
-class MySTT implements STTProvider {
-  async transcribe(audio: Buffer): Promise<string> {
-    // TODO: Replace with your STT implementation
-    throw new Error("Implement STT provider");
-  }
-}
-
-class MyTTS implements TTSProvider {
-  async synthesize(text: string): Promise<Buffer> {
-    // TODO: Replace with your TTS implementation
-    throw new Error("Implement TTS provider");
-  }
-}
-
-class MyLLM implements LLMProvider {
-  async generate(prompt: string, history: Array<{ role: string; content: string }>): Promise<string> {
-    // TODO: Replace with your LLM implementation
-    return \`Echo: \${prompt}\`;
-  }
-}
-
-// ─── Voice bridge server ─────────────────────────────────────────
-
-const stt = new MySTT();
-const tts = new MyTTS();
-const llm = new MyLLM();
-
-const wss = new WebSocketServer({ port: 8765 });
-console.log("Voice Bridge listening on ws://localhost:8765");
-
-wss.on("connection", (ws) => {
-  const history: Array<{ role: string; content: string }> = [];
-
-  ws.on("message", async (data: Buffer) => {
-    try {
-      const transcript = await stt.transcribe(data);
-      history.push({ role: "user", content: transcript });
-
-      const response = await llm.generate(transcript, history);
-      history.push({ role: "assistant", content: response });
-
-      const audio = await tts.synthesize(response);
-      ws.send(audio);
-    } catch (err) {
-      console.error("Pipeline error:", err);
-    }
-  });
-});
+                content: `/**
+ * Custom Voice Bridge Template — Plug in any STT/TTS/LLM.
+ */
+import { WebSocketServer } from "ws";
+
+// ─── Provider interfaces ─────────────────────────────────────────
+
+interface STTProvider {
+  transcribe(audio: Buffer): Promise<string>;
+}
+
+interface TTSProvider {
+  synthesize(text: string): Promise<Buffer>;
+}
+
+interface LLMProvider {
+  generate(prompt: string, history: Array<{ role: string; content: string }>): Promise<string>;
+}
+${vadBlock}
+// ─── Implement your providers here ───────────────────────────────
+
+class MySTT implements STTProvider {
+  async transcribe(audio: Buffer): Promise<string> {
+    // TODO: Replace with your STT implementation
+    throw new Error("Implement STT provider");
+  }
+}
+
+class MyTTS implements TTSProvider {
+  async synthesize(text: string): Promise<Buffer> {
+    // TODO: Replace with your TTS implementation
+    throw new Error("Implement TTS provider");
+  }
+}
+
+class MyLLM implements LLMProvider {
+  async generate(prompt: string, history: Array<{ role: string; content: string }>): Promise<string> {
+    // TODO: Replace with your LLM implementation
+    return \`Echo: \${prompt}\`;
+  }
+}
+
+// ─── Voice bridge server ─────────────────────────────────────────
+
+const stt = new MySTT();
+const tts = new MyTTS();
+const llm = new MyLLM();
+
+const wss = new WebSocketServer({ port: 8765 });
+console.log("Voice Bridge listening on ws://localhost:8765");
+
+wss.on("connection", (ws) => {
+  const history: Array<{ role: string; content: string }> = [];
+
+  ws.on("message", async (data: Buffer) => {
+    try {
+      const transcript = await stt.transcribe(data);
+      history.push({ role: "user", content: transcript });
+
+      const response = await llm.generate(transcript, history);
+      history.push({ role: "assistant", content: response });
+
+      const audio = await tts.synthesize(response);
+      ws.send(audio);
+    } catch (err) {
+      console.error("Pipeline error:", err);
+    }
+  });
+});
 `,
                 description: "Pluggable voice bridge template with STT/TTS/LLM interfaces",
             },