Fix TTS

daemon/index.js

@@ -102,13 +102,40 @@ export class JarvisDaemon extends EventEmitter {
     if (this.state === 'SPEAKING') this.setState('LISTENING');
   }
   _speakReply(spoken) {
-    const playing = this.voiceLoop?.speak?.(spoken);
-    if (!playing) { this._finishSpeech(); return; }
-    Promise.resolve(playing).catch((error) => {
+    const play = async () => {
+      await this.ensureTts();
+      const playing = this.voiceLoop?.speak?.(spoken);
+      if (!playing) {
+        const reason = this.voiceLoop?.status?.errors?.tts;
+        if (reason && reason !== 'Spoken replies are disabled') this.emit('Error', 'TTS', reason);
+        this._finishSpeech();
+        return;
+      }
+      await playing;
+    };
+    Promise.resolve(play()).catch((error) => {
       this.emit('Error', 'TTS', error.message);
       if (this.state === 'SPEAKING') this._finishSpeech();
     });
   }
+  async ensureTts() {
+    if (!this.voiceLoop) return;
+    const settings = voiceSettings();
+    if (!settings.ttsEnabled) return;
+    if (this.voiceLoop.status.tts) return;
+    if (!this.voiceLoop.tts) this.voiceLoop.tts = new QvacVoiceAdapter({ role: 'tts' });
+    try {
+      await this.voiceLoop.tts.start();
+      this.voiceLoop.status.tts = true;
+      delete this.voiceLoop.status.errors.tts;
+      console.log('jarvisd: voice: TTS ready');
+    } catch (error) {
+      const message = String(error?.message || error);
+      this.voiceLoop.status.errors.tts = message;
+      console.error(`jarvisd: voice: TTS: ${message}`);
+      this.emit('Error', 'TTS', message);
+    }
+  }
   cancel() { this.voiceLoop?.interrupt?.(); this.harness.cancel(); this.scheduler.cancelQueued((job) => job.lane === 'voice'); this.computer.revoke(); this.voice.cancel(); this.setState('ARMED'); cancelQvac().catch((error) => this.emit('Error', 'QVAC_CANCEL', error.message)); }
   computerGrant(persist = false) { const result = this.computer.grant({ persist }); this.emit('ComputerStep', JSON.stringify({ action: 'grant', ...result })); this.input.grant({ persist }).then((backend) => { this.computer.setBackend(backend.backend); this.emit('ComputerStep', JSON.stringify({ action: 'backend', ...backend })); }).catch((error) => this.emit('Error', 'CU_GRANT', error.message)); return result; }
   computerRevoke() { this.input.revoke(); this.computer.revoke(); this.emit('ComputerStep', JSON.stringify({ action: 'revoke' })); }
@@ -117,12 +144,15 @@ export class JarvisDaemon extends EventEmitter {
     const settings = voiceSettings();
     const asr = new QvacVoiceAdapter({ role: 'asr' });
     const tts = settings.ttsEnabled ? new QvacVoiceAdapter({ role: 'tts' }) : null;
+    if (!settings.ttsEnabled) console.log('jarvisd: voice: TTS disabled in config.json');
     const loop = new VoiceLoop({ daemon: this, wake: createWakeEngine(settings), asr, tts });
     loop.on('error', (error) => { console.error(`jarvisd: voice: ${error.message}`); this.emit('Error', 'VOICE', error.message); });
     this.voiceLoop = loop;
     try { await loop.start(); this.emit('StateChanged', this.state); } catch (error) {
       this.voiceLoop = null; await loop.stop?.().catch(() => {}); this.emit('Error', 'VOICE_UNAVAILABLE', error.message); throw error;
     }
+    if (loop.status.tts) console.log('jarvisd: voice: TTS ready');
+    else if (loop.status.errors.tts) console.error(`jarvisd: voice: TTS: ${loop.status.errors.tts}`);
   }
   setPushToTalk(pressed) { this.voiceLoop?.setPushToTalk(pressed); this.emit('PushToTalk', Boolean(pressed)); }
   runtimeStatus() { return JSON.stringify({ local: true, qvac: qvacStatus(), scheduler: this.scheduler.status(), scheduler_metrics: this.scheduler.metrics(), telemetry: this.telemetry.snapshot(), computer: this.computer.status(), voice: this.voiceLoop ? { ...this.voiceLoop.metrics.snapshot(), ...this.voiceLoop.status } : null, p2p: { enabled: process.env.JARVIS_P2P_ENABLE === '1', inference: false, memorySync: false } }); }

daemon/transcript.js

@@ -1,9 +1,16 @@
 export const MIN_UTTERANCE_CHARS = 3;
 
+export function isSpeakable(text) {
+  const value = String(text || '').trim();
+  if (!value || value === '[object Object]') return false;
+  if (/\[no speech detected\]|\[blank_audio\]/i.test(value)) return false;
+  if (/^\[[^\]]+\]$/.test(value)) return false;
+  return /[\p{L}\p{N}]/u.test(value);
+}
+
 export function isMeaningfulTranscript(text) {
   const value = String(text || '').trim();
-  if (!value || /\[no speech detected\]|\[blank_audio\]/i.test(value)) return false;
-  if (/^\[[^\]]+\]$/.test(value)) return false;
+  if (!isSpeakable(value)) return false;
   return value.replace(/[^\p{L}\p{N}]/gu, '').length >= MIN_UTTERANCE_CHARS;
 }
 

daemon/voice-adapters.js

@@ -29,8 +29,8 @@ export class QvacVoiceAdapter extends EventEmitter {
     assertSdkVersion();
     await acquireQvac({ auxiliaryOnly: true }); this.acquired = true;
     try {
-      if (this.role !== 'tts') this.asrId = await loadAuxiliaryModel(this.asrModel, { vadModelSrc: 'VAD_SILERO_5_1_2', audio_format: 's16le', language: 'en', no_timestamps: true, vad_params: { threshold: 0.6, min_speech_duration_ms: 300, min_silence_duration_ms: 700, max_speech_duration_s: 15, speech_pad_ms: 200 } }, 'whisper');
-      if (this.role !== 'asr') this.ttsId = await loadAuxiliaryModel(this.ttsModel, { ttsEngine: 'supertonic', language: 'en', voice: 'F1', ttsSpeed: 1.05, ttsNumInferenceSteps: 5 }, 'tts');
+      if (this.role !== 'tts') this.asrId = await loadAuxiliaryModel(this.asrModel, { vadModelSrc: 'VAD_SILERO_5_1_2', audio_format: 's16le', language: 'en', no_timestamps: true, vad_params: { threshold: 0.6, min_speech_duration_ms: 300, min_silence_duration_ms: 700, max_speech_duration_s: 15, speech_pad_ms: 200 } }, 'whispercpp-transcription');
+      if (this.role !== 'asr') this.ttsId = await loadAuxiliaryModel(this.ttsModel, { ttsEngine: 'supertonic', language: 'en', voice: 'F1', ttsSpeed: 1.05, ttsNumInferenceSteps: 5 }, 'tts-ggml');
     } catch (error) { await this.stop(); throw error; }
   }
 

daemon/voice-loop.js

@@ -3,7 +3,7 @@ import { PipeWireCapture } from './audio-pipewire.js';
 import { PipeWirePlayback } from './audio-playback.js';
 import { WakeEngine } from './wake-engine.js';
 import { VadSegmenter } from './vad.js';
-import { isMeaningfulTranscript, SentenceBuffer } from './transcript.js';
+import { isMeaningfulTranscript, isSpeakable, SentenceBuffer } from './transcript.js';
 import { VoiceMetrics } from './voice-metrics.js';
 
 export const POST_PLAYBACK_COOLDOWN_MS = 400;
@@ -37,8 +37,14 @@ export class VoiceLoop extends EventEmitter {
   async start() {
     if (this.running) return;
     for (const [name, adapter] of [['tts', this.tts], ['asr', this.asr]]) {
-      try { if (adapter) { await adapter.start?.(); this.status[name] = true; } }
-      catch (error) { this.status.errors[name] = error.message; this.emit('error', new Error(`${name.toUpperCase()}: ${error.message}`)); }
+      try {
+        if (adapter) { await adapter.start?.(); this.status[name] = true; }
+        else if (name === 'tts') this.status.errors.tts = 'Spoken replies are disabled';
+      } catch (error) {
+        const message = String(error?.message || error);
+        this.status.errors[name] = message;
+        this.emit('error', new Error(`${name.toUpperCase()}: ${message}`));
+      }
     }
     this.running = true;
     if (this.status.asr) {
@@ -53,7 +59,7 @@ export class VoiceLoop extends EventEmitter {
   pushAudio(chunk) {
     if (!this.running || this.daemon?.locked || this.daemon?.state === 'SLEEPING') return;
     if (this.isSpeaking || this.now() < this.cooldownUntil) { this.metrics.feedbackDrop(); return; }
-    this.daemon?.emit('ListeningLevel', Math.min(1, Math.max(0, chunk.length ? 0.01 : 0)));
+    try { this.daemon?.emit('ListeningLevel', Math.min(1, Math.max(0, chunk?.length ? 0.01 : 0))); } catch {}
     if (!this.ptt) this.wake.push(chunk);
     if (this.ptt || this.daemon?.state === 'LISTENING') this.vad.push(chunk);
   }
@@ -89,9 +95,9 @@ export class VoiceLoop extends EventEmitter {
   }
   async speak(text) {
     const generation = this._generation || 0;
-    if (!isMeaningfulTranscript(text) || !this.tts?.speak) { this._releaseSpeaking(); return; }
+    if (!isSpeakable(text) || !this.tts?.speak || !this.status.tts) { this._releaseSpeaking(); return; }
     this.metrics.reply();
-    const sentences = String(text).match(/[^.!?]+[.!?]+|[^.!?]+$/g)?.map((part) => part.trim()).filter(isMeaningfulTranscript) || [];
+    const sentences = String(text).match(/[^.!?]+[.!?]+|[^.!?]+$/g)?.map((part) => part.trim()).filter(isSpeakable) || [];
     if (!sentences.length) { this._releaseSpeaking(); return; }
     this._speechQueue = this._speechQueue.catch(() => {}).then(async () => {
       if (generation !== this._generation) return;
@@ -104,7 +110,7 @@ export class VoiceLoop extends EventEmitter {
   }
   async speakSentence(text) {
     this.isSpeaking = true; this.wake.pause(); this.daemon?.emit('StateChanged', 'SPEAKING');
-    try { const audio = await this.tts.speak(text); await this.playback.play(audio.samples); this.daemon?.emit('SpeakingLevel', 0); }
+    try { const audio = await this.tts.speak(text); await this.playback.play(audio.samples); try { this.daemon?.emit('SpeakingLevel', 0); } catch {} }
     finally {
       this.isSpeaking = false; this.cooldownUntil = this.now() + this.cooldownMs; this.wake.resume();
       if (this.daemon?.state === 'SPEAKING') { this.daemon.voice?.finishSpeaking?.(); this.daemon.setState?.('LISTENING'); }

daemon/voice-settings.js

@@ -2,15 +2,24 @@ import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
 
-export function voiceSettings() {
-  let config = {};
-  try { config = JSON.parse(fs.readFileSync(path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'jarvis/config.json'), 'utf8')); } catch {}
+function flag(value, fallback = true) {
+  if (value === undefined || value === null) return fallback;
+  if (typeof value === 'string') return !['false', '0', 'off', 'no'].includes(value.trim().toLowerCase());
+  return value !== false;
+}
+
+export function voiceSettings(source = null) {
+  let config = source;
+  if (!config) {
+    config = {};
+    try { config = JSON.parse(fs.readFileSync(path.join(process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config'), 'jarvis/config.json'), 'utf8')); } catch {}
+  }
   const phrase = config.wakePhrase || config.wake_phrase || 'hey jarvis';
   const aliases = Array.isArray(config.aliases) ? config.aliases : ['jarvis', 'okay jarvis'];
   return {
     command: process.env.JARVIS_WAKE_COMMAND || config.wakeCommand || config.wake_command || '',
     phrases: [phrase, ...aliases].map((item) => String(item || '').trim()).filter(Boolean),
-    ttsEnabled: config.ttsEnabled !== false && config.tts_enabled !== false,
+    ttsEnabled: flag(config.ttsEnabled ?? config.tts_enabled, true),
     modelProfile: config.modelProfile || config.model_profile || 'laptop-16gb',
   };
 }