@olares/lares-core 0.15.25 → 0.15.27

package/i18n/voice.js

@@ -146,8 +146,9 @@ export const ZH = {
   "error.voice_speak_unready": "当前不能保存语音播报开关",
   "error.voice_gpu_failed": "切换显卡模式失败（{detail}）。可以点重试；仍然失败，请到 Olares「设置 → GPU」查看显卡状态",
   "error.voice_gpu_busy": "显卡正在切换，请等它完成后再操作",
-  "error.voice_gpu_no_gpu": "这台机器没有可用的 NVIDIA 显卡，不能边写边读，请使用「写完再读」",
-  "error.voice_gpu_unsupported": "{model} 不支持显存分片，不能边写边读，请使用「写完再读」",
+  "error.voice_gpu_no_gpu": "这台机器没有可用的 NVIDIA 显卡，不能流式播报，请使用「写完再读」",
+  "error.voice_streaming_time_slice": "当前是时间分片，不能流式播报，请使用「写完再读」",
+  "error.voice_gpu_unsupported": "{model} 不支持显存分片，不能流式播报，请使用「写完再读」",
   "error.voice_gpu_plan_empty": "还没有应用分到显存，显卡模式没有改变。请先在下方「显存分片」里开启要用的应用并填好显存，保存后点重试",
   "error.voice_gpu_plan_over": "这些应用至少需要 {need} GiB 显存，超过了显卡的 {total} GiB，显卡模式没有改变。请在下方「显存分片」里关掉一些应用或调小显存，保存后点重试",
   "error.voice_gpu_plan_floor": "{app}的显存不能低于 {size} GiB",
@@ -214,10 +215,10 @@ export const ZH = {
   "settings.phase.failed": "异常",
   "settings.phase.absent": "未安装",
   "settings.mode.title": "播报方式",
-  "settings.mode.hint": "边写边读用显存分片，写完再读用时间分片。切换约 2–3 分钟，期间模型不可用",
+  "settings.mode.hint": "流式播报只在显存分片下可用。时间分片只能写完再读",
   "settings.mode.gpu": "显卡：{type}",
   "settings.mode.turns": "写完再读",
-  "settings.mode.streaming": "边写边读",
+  "settings.mode.streaming": "流式播报",
   "settings.mode.switching": "正在切换显卡模式…",
   "settings.mode.resumingApp": "正在恢复 {app}…",
   "settings.mode.restoring": "切换没成功，正在恢复原来的应用…",
@@ -242,7 +243,7 @@ export const ZH = {
   "settings.slices.gpu": "显卡",
   "settings.slices.used": "已分配 {used} / {total} GiB",
   "settings.slices.hint": "选择哪些应用常驻显卡、各分多少显存。保存后只重启有改动的应用",
-  "settings.slices.hintPending": "切到边写边读时，按这里的配置分配显存",
+  "settings.slices.hintPending": "切到流式播报时，按这里的配置分配显存",
   "settings.slices.size": "{app}的显存",
   "settings.slices.enable": "{app}参与显存分片",
   "settings.slices.empty": "还没有应用绑定到这张显卡",
@@ -451,8 +452,9 @@ export const EN = {
   "error.voice_gpu_failed":
     "Couldn't switch the GPU mode ({detail}). Retry; if it keeps failing, check the GPU in Olares Settings → GPU",
   "error.voice_gpu_busy": "The GPU is switching. Wait for it to finish",
-  "error.voice_gpu_no_gpu": "This machine has no usable NVIDIA GPU, so reading while writing is unavailable. Use \"When done\"",
-  "error.voice_gpu_unsupported": "{model} does not support memory slicing, so reading while writing is unavailable. Use \"When done\"",
+  "error.voice_gpu_no_gpu": "This machine has no usable NVIDIA GPU, so streaming readout is unavailable. Use \"When done\"",
+  "error.voice_streaming_time_slice": "Time slicing cannot use streaming readout. Use \"When done\"",
+  "error.voice_gpu_unsupported": "{model} does not support memory slicing, so streaming readout is unavailable. Use \"When done\"",
   "error.voice_gpu_plan_empty":
     "No app has a memory slice yet, so the GPU mode was left unchanged. Turn on the apps you need under Memory slices below, set their memory, save, then retry",
   "error.voice_gpu_plan_over":
@@ -525,10 +527,10 @@ export const EN = {
   "settings.phase.failed": "Failed",
   "settings.phase.absent": "Not installed",
   "settings.mode.title": "Reading mode",
-  "settings.mode.hint": "While writing uses memory slicing; when done uses time slicing. Switching takes 2–3 minutes; models are unavailable meanwhile",
+  "settings.mode.hint": "Streaming readout is available only with memory slicing. Time slicing reads the finished answer",
   "settings.mode.gpu": "GPU: {type}",
   "settings.mode.turns": "When done",
-  "settings.mode.streaming": "While writing",
+  "settings.mode.streaming": "Streaming readout",
   "settings.mode.switching": "Switching GPU mode…",
   "settings.mode.resumingApp": "Resuming {app}…",
   "settings.mode.restoring": "The switch failed. Restoring the apps that were running…",
@@ -553,7 +555,7 @@ export const EN = {
   "settings.slices.gpu": "GPU",
   "settings.slices.used": "{used} / {total} GiB allocated",
   "settings.slices.hint": "Choose which apps stay on the GPU and how much memory each gets. Saving restarts only the apps that changed",
-  "settings.slices.hintPending": "Applied when switching to reading while writing",
+  "settings.slices.hintPending": "Applied when switching to streaming readout",
   "settings.slices.size": "Memory for {app}",
   "settings.slices.enable": "{app} uses a memory slice",
   "settings.slices.empty": "No apps are bound to this GPU yet",

package/larepass/settings.js

@@ -111,6 +111,9 @@ export function createHostSettings(request) {
         };
       }, { force: Boolean(force) });
     },
+    async readingMode() {
+      return payload(await request("/api/lares/voice/reading-mode"), "/api/lares/voice/reading-mode");
+    },
     async saveVoice(patch, { diagnostics = true } = {}) {
       const config = payload(
         await request("/api/lares/voice/config", { method: "POST", body: patch }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.25",
+  "version": "0.15.27",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {

package/router/tts.js

@@ -1,3 +1,4 @@
+import { speechInput } from "../voice/tts-input.js";
 import { fetchTtsVoices } from "../voice/tts-voice.js";
 import { VoiceError } from "./stt.js";
 import { routerShimBaseUrl } from "./gateway.js";
@@ -54,8 +55,9 @@ export function pcmToWav(pcm, sampleRate = PCM_RATE) {
  * @returns {Promise<Buffer>}
  */
 export async function synthesize(request) {
-  const text = request.text.trim();
-  if (!text) throw new VoiceError("voice_config_invalid", 400, "nothing to speak");
+  const spoken = request.text.trim();
+  if (!spoken) throw new VoiceError("voice_config_invalid", 400, "nothing to speak");
+  const text = speechInput(request.model, spoken);
   let res;
   try {
     res = await fetch(`${routerShimBaseUrl()}/audio/speech`, {
@@ -92,8 +94,9 @@ export async function synthesize(request) {
  * @param {(chunk: Buffer) => Promise<void> | void} onChunk
  */
 export async function synthesizeStream(request, onChunk) {
-  const text = request.text.trim();
-  if (!text) throw new VoiceError("voice_config_invalid", 400, "nothing to speak");
+  const spoken = request.text.trim();
+  if (!spoken) throw new VoiceError("voice_config_invalid", 400, "nothing to speak");
+  const text = speechInput(request.model, spoken);
   let res;
   try {
     const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);

package/voice/client.js

@@ -125,7 +125,11 @@ export async function saveVoiceSettings(patch) {
     headers: { "content-type": "application/json" },
     body: JSON.stringify(patch),
   });
-  if (!res.ok) throw new Error(String(res.status));
+  if (!res.ok) {
+    const failed = await res.json().catch(() => null);
+    const code = failed?.error?.code;
+    throw Object.assign(new Error(code || String(res.status)), code ? { code } : {});
+  }
   const config = await res.json();
   configRevision++;
   confirmedConfig = config;
@@ -142,6 +146,13 @@ export async function loadGpuMode() {
   return res.json();
 }
 
+/** Reading mode and whether this card can read while writing. */
+export async function loadReadingMode() {
+  const res = await fetch(`${API}/reading-mode`);
+  if (!res.ok) throw new Error(String(res.status));
+  return res.json();
+}
+
 /** A failed GPU request keeps the Host's code and params for gpuProblemText. */
 async function gpuResponse(res) {
   const payload = await res.json().catch(() => null);

package/voice/gpu-mode.js

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+import https from "node:https";
 import { readJsonFile, writeJsonFile } from "../tools/json-file.js";
 import { dshPluginConfigPath } from "../workspace/home.js";
 import { VoiceError } from "../router/stt.js";
@@ -119,18 +121,41 @@ function speechDevice(nodes) {
     ?? null;
 }
 
+let seenGpu = undefined;
+
+/** Last card `speechGpu` observed. `undefined` means it has not been asked yet. */
+export function noteSpeechGpu(gpu) {
+  seenGpu = gpu ?? null;
+}
+
 /**
- * The NVIDIA card the speech models are bound to.
- * @returns {Promise<{ node: string, device: string, model: string, type: string, memory: number, available: string[], bindings: { app: string, memory: number }[] } | null>}
+ * Read-while-writing only while the saved mode asks for it and the card is
+ * memory-sliced. Time slicing cannot keep the language model and speech model
+ * resident together, so a saved streaming flag does not override that.
  */
-export async function speechGpu(options = {}) {
-  const result = await runOlaresCli(["settings", "compute", "list", "-o", "json"], options.spawnFn);
-  if (result.code !== 0 || !Array.isArray(result.json)) {
-    throw new GpuError(cliProblem(result, "voice_gpu_failed"));
+export function streamingEnabled() {
+  return readConfig().streaming === true && seenGpu?.type === "MemorySlice";
+}
+
+/** What the reading-mode control needs, without listing every GPU app. */
+export async function readingModePayload(options = {}) {
+  let gpu = null;
+  let problem = null;
+  try {
+    gpu = await speechGpu(options);
+  } catch (err) {
+    problem = problemOf(err);
   }
-  const device = speechDevice(result.json);
-  if (!device) return null;
   return {
+    streaming: readConfig().streaming === true,
+    allowed: gpu?.type === "MemorySlice",
+    gpu: gpu ? { type: gpu.type, model: gpu.model } : null,
+    problem,
+  };
+}
+
+function gpuFromDevice(device) {
+  const gpu = {
     node: String(device.nodeName ?? ""),
     device: String(device.id ?? ""),
     model: String(device.cardModel ?? ""),
@@ -142,6 +167,133 @@ export async function speechGpu(options = {}) {
       memory: Number(binding?.memory) || 0,
     })).filter((binding) => binding.app),
   };
+  noteSpeechGpu(gpu);
+  return gpu;
+}
+
+const SHARE_MODE_PREFIX = "sharemode.gpu.bytetrade.io/";
+const NVIDIA_REGISTER = "hami.io/node-nvidia-register";
+
+/**
+ * Node annotation `sharemode.gpu.bytetrade.io/<uuid>` uses the platform's
+ * legacy codes: 0 exclusive, 1 memory slice, anything else time slice.
+ */
+export function supportTypeFromShareMode(mode) {
+  if (mode === "0") return "Exclusive";
+  if (mode === "1") return "MemorySlice";
+  return "TimeSlice";
+}
+
+/**
+ * The card the speech models use, from the node's share-mode annotation and
+ * the GPUBinding objects. Memory in those objects is MiB.
+ * @returns {ReturnType<typeof gpuFromDevice> | null}
+ */
+export function gpuFromClusterState(nodeList, bindingList) {
+  const nodes = Array.isArray(nodeList?.items) ? nodeList.items : [];
+  const bindings = Array.isArray(bindingList?.items) ? bindingList.items : [];
+  const speechApps = new Set(Object.values(VOICE_CHARTS).map((chart) => chart.app));
+  const cards = [];
+  for (const node of nodes) {
+    const annotations = node?.metadata?.annotations ?? {};
+    const register = String(annotations[NVIDIA_REGISTER] ?? "");
+    const rows = register.split(":").map((row) => row.split(",")).filter((fields) => fields[0]);
+    for (const [key, value] of Object.entries(annotations)) {
+      if (!key.startsWith(SHARE_MODE_PREFIX)) continue;
+      const device = key.slice(SHARE_MODE_PREFIX.length);
+      if (!device) continue;
+      const card = rows.find((fields) => fields[0] === device);
+      const bound = bindings.filter((item) => item?.spec?.uuid === device);
+      cards.push({
+        node: String(node?.metadata?.name ?? ""),
+        device,
+        model: card?.[4] ? String(card[4]) : "",
+        type: supportTypeFromShareMode(String(value ?? "").trim()),
+        memory: card ? (Number(card[2]) || 0) * MIB : 0,
+        available: ["TimeSlice", "MemorySlice", "Exclusive"],
+        bindings: bound.map((item) => ({
+          app: String(item?.spec?.appName ?? ""),
+          memory: (Number(item?.spec?.memory) || 0) * MIB,
+        })).filter((binding) => binding.app),
+      });
+    }
+  }
+  const chosen = cards.find((card) => card.bindings.some((binding) => speechApps.has(binding.app))) ?? cards[0] ?? null;
+  if (!chosen) return null;
+  noteSpeechGpu(chosen);
+  return chosen;
+}
+
+function kubeGet(path) {
+  return new Promise((resolve, reject) => {
+    Promise.all([
+      readFile("/var/run/secrets/kubernetes.io/serviceaccount/token", "utf8"),
+      readFile("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"),
+    ]).then(([token, ca]) => {
+      const req = https.request({
+        hostname: "kubernetes.default.svc",
+        path,
+        method: "GET",
+        ca,
+        headers: { Authorization: `Bearer ${token.trim()}` },
+        timeout: 8000,
+      }, (res) => {
+        let body = "";
+        res.setEncoding("utf8");
+        res.on("data", (chunk) => { body += chunk; });
+        res.on("end", () => {
+          if (res.statusCode !== 200) {
+            reject(new Error(`kubernetes ${path} returned ${res.statusCode}`));
+            return;
+          }
+          try {
+            resolve(JSON.parse(body));
+          } catch (err) {
+            reject(err);
+          }
+        });
+      });
+      req.on("error", reject);
+      req.on("timeout", () => req.destroy(new Error("kubernetes API timed out")));
+      req.end();
+    }).catch(reject);
+  });
+}
+
+async function speechGpuFromCluster(options) {
+  const get = options.kubeGet ?? kubeGet;
+  const [nodes, bindings] = await Promise.all([
+    get("/api/v1/nodes"),
+    get("/apis/gpu.bytetrade.io/v1alpha1/gpubindings"),
+  ]);
+  return gpuFromClusterState(nodes, bindings);
+}
+
+/**
+ * The NVIDIA card the speech models are bound to.
+ * The pod CLI profile is the first source. When that profile is not mounted,
+ * the node's share-mode annotation is the same fact the settings page shows.
+ * @returns {Promise<{ node: string, device: string, model: string, type: string, memory: number, available: string[], bindings: { app: string, memory: number }[] } | null>}
+ */
+export async function speechGpu(options = {}) {
+  const result = await runOlaresCli(["settings", "compute", "list", "-o", "json"], options.spawnFn);
+  if (result.code === 0 && Array.isArray(result.json)) {
+    const device = speechDevice(result.json);
+    if (!device) {
+      noteSpeechGpu(null);
+      return null;
+    }
+    return gpuFromDevice(device);
+  }
+  const problem = cliProblem(result, "voice_gpu_failed");
+  if (problem.code === "voice_gpu_login") {
+    try {
+      return await speechGpuFromCluster(options);
+    } catch {
+      /* The annotation is unreadable; the CLI failure is what we can report. */
+    }
+  }
+  throw new GpuError(problem);
 }
 
 /**

package/voice/options.js

@@ -24,7 +24,7 @@ export const VOICE_DEFAULTS = {
   language: "",
   speak: false,
   // Read answers while they are written. Needs the GPU in MemorySlice, see gpu-mode.js.
-  streaming: false,
+  streaming: true,
 };
 
 export const VOICE_PRESETS = Object.freeze(["dictation", "chat", "assistant", "direct"]);

package/voice/reply-stream.js

@@ -6,13 +6,17 @@ const STATUS = { voice_reply_invalid: 400, voice_reply_forbidden: 403 };
 const fault = code => new VoiceError(code, STATUS[code] ?? 409, code);
 const identity = source => JSON.stringify([source.sessionId, source.turn, source.step]);
 
-/** Only trusted Agent events may authorize live text; client input supplies an address, never text. */
-export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segmenterFactory = () => createSpeechSegmenter({ now }) } = {}) {
+/**
+ * Trusted Agent text only; a client supplies an address, never the words.
+ * Read-while-writing releases each closed sentence as it arrives. Reading the
+ * finished answer waits until that text has settled. A tool call ends either readout.
+ */
+export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segmenterFactory = () => createSpeechSegmenter({ now }), streaming = () => false } = {}) {
   const rows = new Map();
   const notify = row => { row.version = (row.version || 0) + 1; for (const wake of row.listeners) wake(); };
   const fail = (row, code) => { row.segmenter.reset(); row.ready = []; row.error = code; row.done = true; row.at = now(); notify(row); };
   const advance = row => {
-    if (!row.subscribers || row.error || !row.eligible && !row.done) return;
+    if (!row.subscribers || row.error || streaming() !== true && !row.done) return;
     try { row.ready.push(...row.segmenter.update(row.utterance?.text || "", { done: row.done })); }
     catch (error) { fail(row, error.message === "voice_reply_rewritten" ? error.message : "voice_reply_invalid"); }
   };
@@ -28,7 +32,7 @@ export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segm
         }
         if (rows.size >= 128) return;
         rows.set(key, { sessionId, turn: frame.turn, step: frame.step, attemptId: frame.attemptId,
-          segmenter: segmenterFactory(), ready: [], eligible: frame.speechEligible === true, utterance: null, next: 0, done: false, error: null, at: now(), listeners: new Set(), subscribers: 0 });
+          segmenter: segmenterFactory(), ready: [], utterance: null, next: 0, done: false, error: null, at: now(), listeners: new Set(), subscribers: 0 });
         return;
       }
       for (const row of rows.values()) {

package/voice/service.js

@@ -158,6 +158,12 @@ export async function saveVoiceConfig(body) {
       throw new VoiceError("voice_model_unavailable", 400, "selected speech model is not available");
     }
   }
+  if (patch.streaming === true) {
+    const { speechGpu } = await import("./gpu-mode.js");
+    const gpu = await speechGpu();
+    if (!gpu) throw new VoiceError("voice_gpu_no_gpu", 409, "no NVIDIA GPU");
+    if (gpu.type !== "MemorySlice") throw new VoiceError("voice_streaming_time_slice", 409, gpu.type || "TimeSlice");
+  }
   if (patch.ttsVoiceByModel) {
     const current = readConfig().ttsVoiceByModel;
     const changed = Object.entries(patch.ttsVoiceByModel).filter(([model, voice]) => voice && current[model] !== voice);

package/voice/speech-segmenter.js

@@ -20,30 +20,49 @@ function boundaries(text) {
   return { positions, balanced: !stack.length };
 }
 
-function sentences(text, closed) {
-  const { positions, balanced } = boundaries(text);
-  const ends = new Set();
+function cjkCuts(text, positions) {
+  const cuts = [];
+  for (let i = 0; i < text.length; i++) {
+    if (!/[。！？]/.test(text[i])) continue;
+    let end = i + 1;
+    while (/[”’」』）)\]]/.test(text[end] || "") && end < text.length) end++;
+    if (positions.has(end)) cuts.push(end);
+  }
+  return [...new Set(cuts)].sort((a, b) => a - b);
+}
+
+// sentencex is an English segmenter. A Chinese 。！？ already closed the previous
+// sentence; feeding that terminator back in makes it treat "Mr." as another end.
+function sentenceCuts(slice, sliceClosed) {
+  const parts = segment("en", slice);
+  const ends = [];
   let from = 0;
-  const parts = segment("en", text);
   for (let i = 0; i < parts.length; i++) {
-    const at = text.indexOf(parts[i], from); if (at < 0) continue;
+    const at = slice.indexOf(parts[i], from);
+    if (at < 0) continue;
     from = at + parts[i].length;
-    if (i < parts.length - 1 || closed) ends.add(from);
+    if (i < parts.length - 1) ends.push(from);
+    else if (sliceClosed) ends.push(slice.length);
   }
-  for (let i = 0; i < text.length; i++) {
-    if (/[。！？]/.test(text[i])) {
-      let end = i + 1;
-      while (/[”’」』）)\]]/.test(text[end] || "") && end < text.length) end++;
-      ends.add(end);
-    }
+  return ends;
+}
+
+function sentences(text, closed) {
+  const { positions, balanced } = boundaries(text);
+  const ends = new Set();
+  const cuts = cjkCuts(text, positions);
+  let start = 0;
+  for (const cut of cuts) {
+    for (const end of sentenceCuts(text.slice(start, cut), true)) ends.add(start + end);
+    start = cut;
   }
-  if (closed) ends.add(text.length);
+  for (const end of sentenceCuts(text.slice(start), closed)) ends.add(start + end);
   const out = []; let consumed = 0;
   for (const end of [...ends].sort((a, b) => a - b)) {
     if (!positions.has(end) && !(closed && end === text.length)) continue;
     const sentence = text.slice(consumed, end).trim();
     if (sentence.includes("\uFFFC")) break;
-    if (sentence) out.push(sentence);
+    if (/[\p{L}\p{N}]/u.test(sentence)) out.push(sentence);
     consumed = end;
   }
   return { out, consumed, balanced };

package/voice/spoken-text.js

@@ -100,6 +100,14 @@ function withoutEmoji(text) {
   });
 }
 
+// A longer unbroken identifier is not speech. Synthesizing it stalls the one
+// shared speech path, so this answer and the next one stay silent. Dots stay
+// outside the run so "First one." is still a sentence; a following short
+// extension (`name.jpg`) leaves with the run.
+function withoutUnsayable(text) {
+  return text.replace(/[A-Za-z0-9][A-Za-z0-9_~:/?#@!$&*+=%-]{31,}(?:\.[A-Za-z0-9]{1,8})?/g, "");
+}
+
 /** The assistant's spoken copy; never apply this to stored messages or raw TTS API input. */
 function prepareSource(text, done, structural = false) {
   let pending = false;
@@ -143,9 +151,10 @@ export function spokenLines(text, { done = true } = {}) {
       plain = plain.slice(0, lineStart) + end.slice(0, tail.index);
       pending = true;
     }
-    if (pending || inline.pending) plain += "\uFFFC";
   }
-  return withoutEmoji(plain).split("\n").map((line) => line.replace(/\s+/g, " ").trim());
+  plain = withoutUnsayable(withoutEmoji(plain));
+  if (!done && (pending || inline.pending)) plain += "\uFFFC";
+  return plain.split("\n").map((line) => line.replace(/\s+/g, " ").trim());
 }
 
 
@@ -183,8 +192,9 @@ export function spokenBlocks(text, { done = true } = {}) {
         const tail = [...graphemes.segment(plain.trimEnd())].at(-1);
         if (tail && (emojiRegex().test(tail.segment) || /[\uD800-\uDBFF]$/.test(tail.segment))) { plain = plain.slice(0, tail.index); opaque = true; }
       }
+      plain = withoutUnsayable(withoutEmoji(plain));
       if (!done && opaque) plain += "\uFFFC";
-      plain = withoutEmoji(plain).replace(/\s+/g, " ").trim();
+      plain = plain.replace(/\s+/g, " ").trim();
       const continuation = lists.length && paragraphs.has(items.at(-1));
       if (lists.length) paragraphs.add(items.at(-1));
       if (plain) result.push({ id, text: plain, closed,

package/voice/stream-client.js

@@ -49,7 +49,7 @@ export async function playAudioStream(options) {
     if (!progressNoted) { progressNoted = true; streamMetric(options, { stage: "playback_progress_sent", frames }); }
   },
     onMetric: (event) => { if (event.stage === "playback_started") options.onStatus?.("playing"); streamMetric(options, { ...event, durationMs: Date.now() - started }); } });
-  let chain = Promise.resolve(), complete = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
+  let chain = Promise.resolve(), complete = false, ending = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
   options.controls?.({
     get canPause() { return ready; },
     pause() { if (!ready || paused) return; paused = true; player.pause(); file.pause(); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "pause" })); },
@@ -69,10 +69,14 @@ export async function playAudioStream(options) {
       options.signal?.addEventListener("abort", cancelled, { once: true });
       connection.addEventListener("message", ({ data }) => {
         if (typeof data !== "string" && !firstReceived) { firstReceived = true; streamMetric(options, { stage: "playback_first_received", durationMs: Date.now() - started }); }
+        let event = null;
+        if (typeof data === "string") {
+          try { event = JSON.parse(data); } catch (error) { chain = chain.then(() => { throw error; }).catch(fail); return; }
+          if (event?.type === "done") ending = true;
+        }
         chain = chain.then(async () => {
           if (options.signal?.aborted) throw new Error("voice_cancelled");
           if (typeof data !== "string") { player.write(new Uint8Array(data)); return; }
-          const event = JSON.parse(data);
           if (event.type === "segment") {
             if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
             segmentIndex = event.index;
@@ -88,7 +92,7 @@ export async function playAudioStream(options) {
       connection.addEventListener("error", () => fail(dropped()), { once: true });
       connection.addEventListener("close", () => {
         options.signal?.removeEventListener("abort", cancelled);
-        if (!complete) { const error = dropped(); noteFailure(error); reject(error); }
+        if (!complete && !ending) { const error = dropped(); noteFailure(error); reject(error); }
       }, { once: true });
       if (options.signal?.aborted) cancelled();
     });

package/voice/stream-gateway.js

@@ -159,7 +159,9 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
               else if (event.type === "error") throw fault(event.code || "voice_stream_failed");
             }
           };
-          void pump().catch((cause) => { if (!abort.signal.aborted) error(cause); }).finally(() => { unsub(); close(); });
+          // `done` means the bytes have been handed over. The browser still has up to
+          // the two-second send-ahead queued. Closing now is a disconnect and stops that tail.
+          void pump().catch((cause) => { if (!abort.signal.aborted) error(cause); }).finally(() => unsub());
         }
       });
     },

package/voice/tts-input.js

@@ -0,0 +1,10 @@
+const QWEN_12HZ = /qwen3-tts|audioqwen3tts/i;
+
+/** 12Hz Qwen drops its last codec frames. This tail is not spoken, so those frames land on it. */
+export const QWEN_SPEECH_TAIL = " ^.";
+
+export function speechInput(model, text) {
+  const body = String(text ?? "");
+  if (!QWEN_12HZ.test(String(model ?? ""))) return body;
+  return body.endsWith(QWEN_SPEECH_TAIL) ? body : `${body}${QWEN_SPEECH_TAIL}`;
+}

package/voice/tts-preview.js

@@ -1,8 +1,10 @@
+import { speechInput } from "./tts-input.js";
+
 /** Explicit audition is independent of automatic read-aloud and business sessions. */
 export async function previewTts({ model, voice, text, signal }, { fetcher = fetch, createAudio = url => new Audio(url) } = {}) {
   const response = await fetcher("/llm/v1/audio/speech", {
     method: "POST", headers: { "content-type": "application/json" }, signal,
-    body: JSON.stringify({ model, input: text, response_format: "wav", ...(voice ? { voice } : {}) }),
+    body: JSON.stringify({ model, input: speechInput(model, text), response_format: "wav", ...(voice ? { voice } : {}) }),
   });
   if (!response.ok) throw new Error("tts_preview_failed");
   const blob = await response.blob(); signal.throwIfAborted();