@olares/lares-core 0.15.7 → 0.15.10

package/skills/state.js

@@ -0,0 +1,142 @@
+import { cpSync, existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { HttpError } from "../tools/http.js";
+import { readJsonFile, writeJsonFile } from "../tools/json-file.js";
+import { ALWAYS_ON_PREFIXES, OFFICIAL_PACKS, packById, packForSkillDir } from "./packs.js";
+
+export function packsStatePath(dataDir) {
+  return join(dataDir, "skill-packs.json");
+}
+
+export function runtimeSkillsDir(dataDir) {
+  return join(dataDir, "skills");
+}
+
+export function packCacheDir(dataDir, packId) {
+  return join(dataDir, "skill-packs", packId);
+}
+
+export function defaultCatalogRoot() {
+  return process.env.LARES_SKILLS_ROOT?.trim() || join(process.cwd(), "packages", "skills");
+}
+
+function directoryNames(root) {
+  if (!existsSync(root)) return [];
+  return readdirSync(root).filter((name) => {
+    try {
+      return statSync(join(root, name)).isDirectory();
+    } catch {
+      return false;
+    }
+  });
+}
+
+export function readEnabledPacks(dataDir) {
+  const raw = readJsonFile(packsStatePath(dataDir));
+  const listed = Array.isArray(raw?.enabled) ? raw.enabled : [];
+  return listed.filter((id) => typeof id === "string" && packById(id));
+}
+
+export function writeEnabledPacks(dataDir, enabled) {
+  writeJsonFile(packsStatePath(dataDir), { enabled: [...new Set(enabled)] });
+}
+
+export function cachedSkillDirs(dataDir, pack) {
+  return directoryNames(packCacheDir(dataDir, pack.id)).filter((name) => name.startsWith(pack.prefix));
+}
+
+export function packDownloaded(dataDir, pack) {
+  return cachedSkillDirs(dataDir, pack).length > 0;
+}
+
+function shouldKeepRuntimeDir(name, enabledIds) {
+  if (ALWAYS_ON_PREFIXES.some((prefix) => name.startsWith(prefix))) return true;
+  const pack = packForSkillDir(name);
+  if (!pack) return false;
+  return enabledIds.includes(pack.id);
+}
+
+/**
+ * Image catalog supplies always-on skills (olares-* / lares-*).
+ * Optional packs are copied from their download cache only when enabled.
+ */
+export function syncRuntimeSkills(catalogRoot, dataDir) {
+  const targetDir = runtimeSkillsDir(dataDir);
+  mkdirSync(targetDir, { recursive: true });
+  const enabled = readEnabledPacks(dataDir);
+
+  for (const name of directoryNames(targetDir)) {
+    if (shouldKeepRuntimeDir(name, enabled)) continue;
+    rmSync(join(targetDir, name), { recursive: true, force: true });
+  }
+
+  for (const name of directoryNames(catalogRoot)) {
+    if (!ALWAYS_ON_PREFIXES.some((prefix) => name.startsWith(prefix))) continue;
+    const to = join(targetDir, name);
+    rmSync(to, { recursive: true, force: true });
+    cpSync(join(catalogRoot, name), to, { recursive: true });
+  }
+
+  for (const pack of OFFICIAL_PACKS) {
+    if (!enabled.includes(pack.id)) continue;
+    for (const name of cachedSkillDirs(dataDir, pack)) {
+      const to = join(targetDir, name);
+      rmSync(to, { recursive: true, force: true });
+      cpSync(join(packCacheDir(dataDir, pack.id), name), to, { recursive: true });
+    }
+  }
+  return targetDir;
+}
+
+export function writeExportedSkills(cacheDir, files) {
+  mkdirSync(cacheDir, { recursive: true });
+  for (const name of directoryNames(cacheDir)) {
+    rmSync(join(cacheDir, name), { recursive: true, force: true });
+  }
+  for (const file of files) {
+    if (!file?.name || typeof file.body !== "string") continue;
+    const dir = join(cacheDir, file.name);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, "SKILL.md"), file.body);
+  }
+}
+
+export function listOfficialPacks(dataDir, cliReady = {}) {
+  const enabled = readEnabledPacks(dataDir);
+  return OFFICIAL_PACKS.map((pack) => {
+    const cached = cachedSkillDirs(dataDir, pack);
+    const downloaded = cached.length > 0;
+    const on = enabled.includes(pack.id);
+    return {
+      id: pack.id,
+      official: true,
+      optional: true,
+      downloaded,
+      enabled: on,
+      skillCount: downloaded ? cached.length : 0,
+      cliBin: pack.cli?.bin ?? null,
+      cliReady: Boolean(cliReady[pack.id]),
+    };
+  });
+}
+
+export function enableOfficialPack(catalogRoot, dataDir, id) {
+  const pack = packById(id);
+  if (!pack) throw new HttpError("unknown_pack", 404, `unknown skill pack ${id}`);
+  if (!packDownloaded(dataDir, pack)) {
+    throw new HttpError("pack_not_downloaded", 409, `skill pack ${id} is not downloaded`);
+  }
+  writeEnabledPacks(dataDir, [...readEnabledPacks(dataDir), pack.id]);
+  syncRuntimeSkills(catalogRoot, dataDir);
+  return pack;
+}
+
+export function disableOfficialPack(catalogRoot, dataDir, id) {
+  const pack = packById(id);
+  if (!pack) throw new HttpError("unknown_pack", 404, `unknown skill pack ${id}`);
+  writeEnabledPacks(dataDir, readEnabledPacks(dataDir).filter((item) => item !== pack.id));
+  syncRuntimeSkills(catalogRoot, dataDir);
+  return pack;
+}
+
+export { packForSkillDir };

package/tools/crypto-uuid.js

@@ -1,3 +1,5 @@
+import { injectHeadScript } from "./head-script.js";
+
 /**
  * Olares LAN zone is plain http, so browsers withhold `crypto.randomUUID`.
  * dsh mints host-RPC ids with it; `getRandomValues` stays available.
@@ -16,11 +18,6 @@ export const UUID_SHIM = `(function () {
   };
 })();`;
 
-const HEAD_OPEN = /<head[^>]*>/i;
-
 export function injectUuidShim(html) {
-  if (html.includes("data-lares-uuid-shim")) return html;
-  const tag = `<script data-lares-uuid-shim>${UUID_SHIM}</script>`;
-  const head = HEAD_OPEN.exec(html);
-  return head === null ? `${tag}${html}` : html.replace(HEAD_OPEN, `${head[0]}${tag}`);
+  return injectHeadScript(html, { marker: "data-lares-uuid-shim", code: UUID_SHIM });
 }

package/tools/head-script.js

@@ -0,0 +1,15 @@
+const HEAD_OPEN = /<head[^>]*>/i;
+
+/**
+ * Put an inline script at the top of <head> so it runs before the shell bundle.
+ * The marker attribute keeps repeated index taps idempotent.
+ *
+ * @param {string} html
+ * @param {{marker: string, code: string}} script
+ */
+export function injectHeadScript(html, { marker, code }) {
+  if (html.includes(marker)) return html;
+  const tag = `<script ${marker}>${code}</script>`;
+  const head = HEAD_OPEN.exec(html);
+  return head === null ? `${tag}${html}` : html.replace(HEAD_OPEN, `${head[0]}${tag}`);
+}

package/voice/agent.js

@@ -0,0 +1,50 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { VoiceError } from "../router/stt.js";
+
+const DEFAULT_DIR = "/data/voice";
+const WAIT_MS = 30_000;
+const AGENT_STALE_MS = 60_000;
+
+async function readJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function agentIsLive(info, now) {
+  return Boolean(info && typeof info.at === "number" && now - info.at * 1000 < AGENT_STALE_MS);
+}
+
+export function voiceDir(options) {
+  return options.dir ?? process.env.LARES_VOICE_BLUETOOTH_DIR ?? DEFAULT_DIR;
+}
+
+/** The host agent, or null when this machine has no bluetooth helper running. */
+export async function liveAgent(options = {}) {
+  const now = options.now ?? Date.now;
+  const info = await readJson(`${voiceDir(options)}/agent.json`);
+  return agentIsLive(info, now()) ? info : null;
+}
+
+export async function askAgent(op, fields, options) {
+  const dir = voiceDir(options);
+  const now = options.now ?? Date.now;
+  const sleep = options.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  if (!await liveAgent(options)) {
+    throw new VoiceError("voice_bluetooth_unavailable", 503, "bluetooth agent is not running");
+  }
+  const id = options.id ?? randomUUID();
+  await mkdir(dir, { recursive: true });
+  await rm(`${dir}/result.json`, { force: true });
+  await writeFile(`${dir}/request.json`, JSON.stringify({ id, op, ...fields }));
+  const deadline = now() + (options.timeoutMs ?? WAIT_MS);
+  while (now() < deadline) {
+    const result = await readJson(`${dir}/result.json`);
+    if (result && result.id === id) return result;
+    await sleep(200);
+  }
+  throw new VoiceError("voice_bluetooth_unavailable", 503, "bluetooth agent did not answer");
+}

package/voice/capture.js

@@ -0,0 +1,250 @@
+import { pcmToWav } from "../router/tts.js";
+import { ENDPOINT, createSpeechEndpoint } from "./endpoint.js";
+import { MIN_RECORDING_MS } from "./recorder.js";
+
+const FRAME_BYTES = 1024;
+const FRAME_MS = 32;
+const NO_INPUT_MS = 10_000;
+const POLL_MS = 40;
+const CLIENT_LOST_MS = 5000;
+const HOST_RATE = 16_000;
+const PLAYBACK_SETTLE_MS = 320;
+const PLAYBACK_LEADING_MS = 2500;
+
+/**
+ * The mic still hears the end of playback after the speaker stops. That tail
+ * is loud and then quiet, so it would complete the take before anyone speaks.
+ * Drop it once the input has gone quiet. Sound that never lets up is the
+ * person already talking, and that stays in the take.
+ */
+function createPlaybackGate() {
+  let residue = false;
+  let listening = false;
+  let quietMs = 0;
+  let loudMs = 0;
+  return (audible, rms) => {
+    if (listening) return "listen";
+    const quiet = !audible || rms < ENDPOINT.floor;
+    if (!residue) {
+      if (quiet) {
+        quietMs += FRAME_MS;
+        if (quietMs >= PLAYBACK_SETTLE_MS) listening = true;
+        return listening ? "listen" : "wait";
+      }
+      residue = true;
+      quietMs = 0;
+      loudMs = FRAME_MS;
+      return "wait";
+    }
+    if (quiet) {
+      quietMs += FRAME_MS;
+      loudMs = 0;
+      if (quietMs >= PLAYBACK_SETTLE_MS) {
+        listening = true;
+        return "drop";
+      }
+      return "wait";
+    }
+    quietMs = 0;
+    loudMs += FRAME_MS;
+    if (loudMs >= PLAYBACK_LEADING_MS) {
+      listening = true;
+      return "listen";
+    }
+    return "wait";
+  };
+}
+
+/**
+ * Loudness of one 16-bit little-endian frame, and whether it is live microphone
+ * signal. The headset link opens with a short full-scale burst inside digital
+ * silence; a frame that is mostly exact zeros is not the microphone yet.
+ */
+export function pcm16Level(bytes) {
+  const samples = Math.floor(bytes.length / 2);
+  if (!samples) return { rms: 0, audible: false };
+  let sum = 0;
+  let zeros = 0;
+  for (let i = 0; i < samples; i += 1) {
+    const sample = bytes.readInt16LE(i * 2);
+    if (sample === 0) zeros += 1;
+    const unit = sample / 32768;
+    sum += unit * unit;
+  }
+  return { rms: Math.sqrt(sum / samples), audible: zeros * 2 < samples };
+}
+
+/**
+ * One take recorded on the machine that owns the headset.
+ * `skipped` means there is no headset microphone on this machine.
+ */
+export function createCaptureSession(io) {
+  const sleep = io.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
+  const now = io.now ?? Date.now;
+  let job = null;
+
+  function status() {
+    if (!job) return { phase: "idle" };
+    job.seen = now();
+    return {
+      phase: job.phase,
+      text: job.text ?? "",
+      error: job.error ?? "",
+      at: job.recordingAt ?? 0,
+    };
+  }
+
+  function stop(cancel) {
+    if (!job) return;
+    job.seen = now();
+    if (cancel) {
+      job.cancel = true;
+      job.controller.abort();
+    }
+    else job.stop = true;
+  }
+
+  async function start() {
+    if (job && (job.phase === "preparing" || job.phase === "recording" || job.phase === "transcribing")) {
+      const previous = job;
+      previous.cancel = true;
+      previous.controller.abort();
+      for (let attempts = 0; job === previous && attempts < 25; attempts += 1) {
+        await sleep(POLL_MS);
+      }
+      if (job === previous) throw new Error("voice_failed");
+    }
+    const run = {
+      phase: "preparing",
+      text: "",
+      error: "",
+      recordingAt: 0,
+      seen: now(),
+      cancel: false,
+      stop: false,
+      controller: new AbortController(),
+    };
+    job = run;
+    const opened = await io.open();
+    if (run.cancel) {
+      await io.close?.();
+      run.phase = "idle";
+      job = null;
+      return { cancelled: true };
+    }
+    if (opened?.skipped) {
+      job = null;
+      return { skipped: true };
+    }
+    if (!opened?.ready) {
+      run.phase = "error";
+      run.error = "voice_bluetooth_not_ready";
+      throw new Error("voice_bluetooth_not_ready");
+    }
+
+    let endpoint = createSpeechEndpoint();
+    const gate = opened.settle ? createPlaybackGate() : null;
+    let offset = Number(opened.offset) || 0;
+    let pending = Buffer.alloc(0);
+    let pcm = Buffer.alloc(0);
+    let utteranceFrom = 0;
+    const started = now();
+    // `live`: the link delivers samples. Room noise is live too, so only
+    // `spoke` (a speech-level frame) keeps the take open past NO_INPUT_MS.
+    let live = false;
+    let spoke = false;
+    run.phase = "recording";
+    run.recordingAt = now();
+    run.seen = run.recordingAt;
+
+    void (async () => {
+      try {
+        while (run === job && run.phase !== "done" && run.phase !== "error" && run.phase !== "idle") {
+          if (run.phase === "recording" && now() - run.seen > CLIENT_LOST_MS) run.cancel = true;
+          const fresh = await io.read(offset);
+          offset += fresh.length;
+          if (fresh.length) {
+            pcm = Buffer.concat([pcm, fresh]);
+            pending = Buffer.concat([pending, fresh]);
+          }
+          while (pending.length >= FRAME_BYTES) {
+            const frame = pending.subarray(0, FRAME_BYTES);
+            pending = pending.subarray(FRAME_BYTES);
+            const level = pcm16Level(frame);
+            if (gate) {
+              const verdict = gate(level.audible, level.rms);
+              if (verdict === "wait") continue;
+              if (verdict === "drop") {
+                utteranceFrom = pcm.length - pending.length;
+                endpoint = createSpeechEndpoint();
+                continue;
+              }
+            }
+            if (level.audible) live = true;
+            if (level.audible && level.rms >= ENDPOINT.floor) spoke = true;
+            if (live && endpoint.push(1, level.rms, FRAME_MS)) run.stop = true;
+          }
+          if (run.cancel) {
+            await io.close?.();
+            run.phase = "idle";
+            if (job === run) job = null;
+            return;
+          }
+          if (!spoke && now() - started >= NO_INPUT_MS) {
+            await io.close?.();
+            if (!live) await io.reset?.();
+            run.phase = "error";
+            run.error = "voice_no_input";
+            return;
+          }
+          if (run.stop) {
+            const audio = pcm.subarray(utteranceFrom);
+            const durationMs = (audio.length / 2 / HOST_RATE) * 1000;
+            await io.close?.();
+            if (durationMs < MIN_RECORDING_MS) {
+              run.phase = "error";
+              run.error = "voice_too_short";
+              return;
+            }
+            if (!live) {
+              await io.reset?.();
+              run.phase = "error";
+              run.error = "voice_no_input";
+              return;
+            }
+            run.phase = "transcribing";
+            try {
+              run.text = String(await io.transcribe(
+                pcmToWav(audio, HOST_RATE),
+                run.controller.signal,
+              ) ?? "");
+            } catch (err) {
+              if (run.cancel || run.controller.signal.aborted) {
+                run.phase = "idle";
+                if (job === run) job = null;
+                return;
+              }
+              throw err;
+            }
+            if (run.cancel) {
+              run.phase = "idle";
+              if (job === run) job = null;
+              return;
+            }
+            run.phase = "done";
+            return;
+          }
+          await sleep(POLL_MS);
+        }
+      } catch {
+        await io.close?.().catch(() => {});
+        run.phase = "error";
+        run.error = "voice_failed";
+      }
+    })();
+
+    return { recording: true, at: run.recordingAt };
+  }
+
+  return { start, stop, status };
+}

package/voice/client.js

@@ -20,10 +20,73 @@ export async function loadVoiceSettings(options = {}) {
       config,
       status,
       sttModels: Array.isArray(models.stt) ? models.stt : [],
+      ttsModels: Array.isArray(models.tts) ? models.tts : [],
+      charts: {
+        stt: chartView(models.charts?.stt),
+        tts: chartView(models.charts?.tts),
+      },
     };
   }, options);
 }
 
+function chartView(row) {
+  const phase = row?.phase;
+  return {
+    phase: phase === "running" || phase === "stopped" || phase === "busy" || phase === "failed" ? phase : "absent",
+    state: typeof row?.state === "string" ? row.state : "",
+  };
+}
+
+async function postInstall(body) {
+  const res = await fetch(`${API}/install`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) throw new Error(String(res.status));
+  return loadVoiceSettings({ force: true });
+}
+
+export function installVoiceChart(kind) {
+  return postInstall({ kind });
+}
+
+export function voiceChartAction(kind, op) {
+  return postInstall({ kind, op });
+}
+
+export function wavBlob(base64) {
+  const raw = atob(String(base64 ?? ""));
+  const bytes = new Uint8Array(raw.length);
+  for (let i = 0; i < raw.length; i += 1) bytes[i] = raw.charCodeAt(i);
+  return new Blob([bytes], { type: "audio/wav" });
+}
+
+export async function postSpeak(text) {
+  const res = await fetch(`${API}/speak`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ text }),
+  });
+  let body = null;
+  try {
+    body = await res.json();
+  } catch {
+    body = null;
+  }
+  if (!res.ok || typeof body?.audio !== "string") throw new Error(transcribeErrorCode(body));
+  return {
+    bluetooth: body.bluetooth === "played" ? "played" : "skipped",
+    blob: wavBlob(body.audio),
+  };
+}
+
+export async function postPlaybackStop(signal) {
+  const res = await fetch(`${API}/playback/stop`, { method: "POST", signal });
+  if (!res.ok) throw new Error(String(res.status));
+  return res.json();
+}
+
 export async function saveVoiceSettings(patch) {
   const res = await fetch(`${API}/config`, {
     method: "POST",
@@ -34,41 +97,80 @@ export async function saveVoiceSettings(patch) {
   return loadVoiceSettings({ force: true });
 }
 
-export class TranscriptQueue {
-  constructor() {
-    this.pending = null;
-  }
+function transcribeErrorCode(payload) {
+  const code = payload && typeof payload === "object" ? payload.error?.code : undefined;
+  return typeof code === "string" ? code : "voice_failed";
+}
 
-  apply(text, ready, draft, setDraft) {
-    if (!text) return;
-    if (ready) setDraft(mergeTranscript(draft, text));
-    else this.pending = text;
+export async function postBluetooth(body, signal) {
+  const res = await fetch(`${API}/bluetooth`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body ?? {}),
+    signal,
+  });
+  let payload = null;
+  try {
+    payload = await res.json();
+  } catch {
+    payload = null;
   }
+  if (!res.ok) throw new Error(transcribeErrorCode(payload));
+  return payload;
+}
+
+export function scanBluetoothDevices(signal) {
+  return postBluetooth({ op: "scan" }, signal);
+}
 
-  flush(ready, draft, setDraft) {
-    if (!ready || this.pending === null) return;
-    const text = this.pending;
-    this.pending = null;
-    setDraft(mergeTranscript(draft, text));
+export function connectBluetoothDevice(address, signal) {
+  return postBluetooth({ op: "connect", address }, signal);
+}
+
+async function readVoiceJson(res) {
+  let payload = null;
+  try {
+    payload = await res.json();
+  } catch {
+    payload = null;
   }
+  if (!res.ok) throw new Error(transcribeErrorCode(payload));
+  return payload;
 }
 
-export function mergeTranscript(draft, transcript) {
-  const base = String(draft ?? "").replace(/\s+$/, "");
-  const text = String(transcript ?? "").trim();
-  if (!text) return String(draft ?? "");
-  if (!base) return text;
-  if (/^[,.;!?，。；！？、]/.test(text)) return `${base}${text}`;
-  return `${base} ${text}`;
+/** Host recording. `skipped` means the headset microphone is not available. */
+export async function postCaptureStart(signal) {
+  return readVoiceJson(await fetch(`${API}/capture`, { method: "POST", signal }));
 }
 
-function transcribeErrorCode(payload) {
-  const code = payload && typeof payload === "object" ? payload.error?.code : undefined;
-  return typeof code === "string" ? code : "voice_failed";
+export async function getCapture(signal) {
+  return readVoiceJson(await fetch(`${API}/capture`, { signal }));
+}
+
+export async function postCaptureStop(signal) {
+  return readVoiceJson(await fetch(`${API}/capture/stop`, { method: "POST", signal }));
+}
+
+export async function postCaptureCancel(signal) {
+  return readVoiceJson(await fetch(`${API}/capture/cancel`, { method: "POST", signal }));
+}
+
+export async function postBluetoothReady(signal) {
+  const res = await fetch(`${API}/ready`, { method: "POST", signal });
+  if (!res.ok) {
+    let payload = null;
+    try {
+      payload = await res.json();
+    } catch {
+      /* fall back to the generic code */
+    }
+    throw new Error(transcribeErrorCode(payload));
+  }
+  return res.json();
 }
 
 /**
- * The only voice call that carries a body, and so the only one that cannot go
+ * The only voice call that carries an audio body, and so the only one that cannot go
  * through `createHostSettings`. Like the upload it must accept the host's
  * `request` port: a cross-origin host page sends no Olares cookie, so a plain
  * `fetch` here answers 401 even though `/config`, `/status` and `/models` — which

package/voice/config.js

@@ -6,7 +6,9 @@ export { STT_LANGUAGE_CHOICES, VOICE_AUTO, voiceMenuValue, voiceValueFromMenu }
 
 const DEFAULTS = {
   model: "",
+  ttsModel: "",
   language: "",
+  speak: false,
 };
 
 const WRITABLE = new Set(Object.keys(DEFAULTS));
@@ -23,9 +25,14 @@ export function validateConfigPatch(raw) {
   const patch = {};
   for (const [key, value] of Object.entries(raw)) {
     if (!WRITABLE.has(key)) invalid(`unknown voice setting: ${key}`);
+    if (key === "speak") {
+      if (typeof value !== "boolean") invalid("speak must be a boolean");
+      patch.speak = value;
+      continue;
+    }
     if (typeof value !== "string") invalid(`${key} must be a string`);
     const normalized = value.trim();
-    if (key === "model" && !SAFE_MODEL.test(normalized)) invalid("invalid voice model");
+    if ((key === "model" || key === "ttsModel") && !SAFE_MODEL.test(normalized)) invalid("invalid voice model");
     if (key === "language" && !SUPPORTED_LANGUAGES.has(normalized)) invalid("unsupported recognition language");
     patch[key] = normalized;
   }
@@ -41,9 +48,12 @@ export function readConfig() {
   const stored = readJsonFile(configPath());
   const merged = { ...DEFAULTS };
   const model = typeof stored?.model === "string" ? stored.model.trim() : "";
+  const ttsModel = typeof stored?.ttsModel === "string" ? stored.ttsModel.trim() : "";
   const language = typeof stored?.language === "string" ? stored.language.trim() : "";
   if (SAFE_MODEL.test(model)) merged.model = model;
+  if (SAFE_MODEL.test(ttsModel)) merged.ttsModel = ttsModel;
   if (SUPPORTED_LANGUAGES.has(language)) merged.language = language;
+  if (stored?.speak === true) merged.speak = true;
   return merged;
 }