@olares/lares-core 0.15.28 → 0.15.30

package/voice/lares-realtime-gateway.js

@@ -16,6 +16,13 @@ const SPEECH_RMS = 0.004;
 // and a suspected interruption that never resolves stops the reply.
 const BARGE_IN_MS = 500;
 const BARGE_IN_LIMIT_MS = 10_000;
+// How far ahead of the client's actual playout the Host may send. The client's
+// AudioWorklet keeps a bounded queue; sending a whole answer at network speed
+// overflowed it and dropped audio.
+const PLAY_AHEAD_MS = 2_000;
+// A temporarily interrupted AudioContext (device switch, lock screen) must not
+// end a reply; only a client that stays silent this long is treated as stuck.
+const PLAYOUT_STALL_MS = 30_000;
 const TICKET_MS = 30_000;
 // Usage lives in the child ASR/LLM/TTS requests; the OpenAI shape stays parseable (Router ADR-83).
 const ZERO_USAGE = Object.freeze({ total_tokens: 0, input_tokens: 0, output_tokens: 0, input_token_details: { text_tokens: 0, audio_tokens: 0, cached_tokens: 0 }, output_token_details: { text_tokens: 0, audio_tokens: 0 } });
@@ -46,7 +53,7 @@ export function joinSpoken(parts) {
  * `lares-realtime-v1` (docs/realtime-protocol.md) on one endpoint. Bearer voice-key callers get a
  * scope owned by the socket; ticket sockets attach to the Lares client's open voice scope.
  */
-export function createLaresRealtimeGateway({ service, config, transcribe, synthesize, openTranscription, keys, hostOwner = "", hostAudio, busyDefault = () => "queue", bargeIn = () => process.env.LARES_VOICE_BARGE_IN === "1", segment = speechSegments, onError = () => {}, onOpen = () => {}, limit = 64 }) {
+export function createLaresRealtimeGateway({ service, config, transcribe, synthesize, openTranscription, keys, hostOwner = "", hostAudio, busyDefault = () => "queue", bargeIn = () => process.env.LARES_VOICE_BARGE_IN === "1", segment = speechSegments, onError = () => {}, onOpen = () => {}, limit = 64, playbackAckGraceMs = 60_000 }) {
   const server = new WebSocketServer({ noServer: true, maxPayload: 96 * 1024, perMessageDeflate: false, handleProtocols: (values) => values.has("lares-voice") ? "lares-voice" : false });
   const clients = new Map();
   const tickets = new Map();
@@ -61,14 +68,31 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
     let closed = false, busy = false, pendingCommit = false, configuring = false, alive = true, generation = 0, submittedTurns = 0;
     let response = null, awaitingPlayback = false, acknowledges = false, lastReply = null, lastSpoken = null, turn = null, port = null, unbind = () => {};
     let hostOutput = Promise.resolve();
+    let ackTimer = null;
     const tasks = new Map();
     const spoken = new Map();
     const played = new Map();
 
+    // A client that vanishes in the middle of a reply never acknowledges it.
+    // Without a watchdog the half-duplex gate stays closed for that connection
+    // and every later utterance fails with waiting_for_playback.
+    const PLAYBACK_ACK_GRACE_MS = playbackAckGraceMs;
+    const clearAckWatch = () => { if (ackTimer) { clearTimeout(ackTimer); ackTimer = null; } };
+    const watchAck = () => {
+      clearAckWatch();
+      if (!awaitingPlayback || closed) return;
+      ackTimer = setTimeout(() => {
+        ackTimer = null;
+        if (closed || !awaitingPlayback) return;
+        awaitingPlayback = false;
+        send({ type: "lares.playback.timeout" });
+      }, PLAYBACK_ACK_GRACE_MS);
+      ackTimer.unref?.();
+    };
+
     const bargeActive = () => type === "realtime" && !headset && echoCancellation && bargeIn() === true;
     const send = (event) => {
-      if (client.readyState !== 1) return;
-      if (client.bufferedAmount > 1024 * 1024) { close(); return; }
+      if (closed || client.readyState !== 1) return;
       client.send(JSON.stringify({ event_id: `event_${randomUUID()}`, ...event }));
     };
     const report = (cause, eventId) => {
@@ -98,6 +122,9 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
     };
     const finish = (current, status) => {
       if (response === current) response = null;
+      // Audio that never left the server will not be acknowledged. Holding the
+      // gate here is how a failed or empty reply silences every later one.
+      if (!current.outputMs) { awaitingPlayback = false; clearAckWatch(); }
       if (current.done) return;
       current.done = true;
       remember(current);
@@ -121,6 +148,7 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
       current.suspended?.settle("stop");
       if (headset) { hostOutput = Promise.resolve(); void Promise.resolve(port?.interrupt()).catch(() => close()); send({ type: "lares.device.playback", playing: false }); }
       awaitingPlayback = false;
+      clearAckWatch();
       finish(current, status);
       if (truncate) truncateTo(current, played.get(current.itemId) ?? 0);
     };
@@ -132,11 +160,36 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
         current.outputMs += audio.length / BYTES_PER_MS;
         return hostOutput;
       }
-      if (acknowledges) awaitingPlayback = true;
+      if (acknowledges) { awaitingPlayback = true; watchAck(); }
+      // A long reply is several seconds of PCM. Dumping it in one burst fills the
+      // socket and used to close the call, which cut the readout off and made the
+      // client's next progress tick throw voice_disconnected. Wait for the buffer
+      // the way the speech stream does; a stuck client fails this reply only.
+      const OUTPUT_BUFFER = 128 * 1024;
+      let sentAt = Date.now();
+      let lastPlayed = played.get(current.itemId) ?? 0;
+      let playedAt = Date.now();
       for (let offset = 0; offset < audio.length; offset += CHUNK_BYTES) {
+        while (client.bufferedAmount > OUTPUT_BUFFER) {
+          if (current.abort.signal.aborted || current.done || closed || client.readyState !== 1) return;
+          if (Date.now() - sentAt > 10_000) throw new Error("voice_audio_backpressure");
+          await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+        // Playout credit: never get more than two seconds ahead of what the
+        // client has actually rendered. Progress advances in real time, so a
+        // long answer waits here instead of filling the worklet queue.
+        while (acknowledges && current.outputMs - lastPlayed > PLAY_AHEAD_MS) {
+          if (current.abort.signal.aborted || current.done || closed || client.readyState !== 1) return;
+          const heard = played.get(current.itemId) ?? 0;
+          if (heard > lastPlayed) { lastPlayed = heard; playedAt = Date.now(); }
+          if (Date.now() - playedAt > PLAYOUT_STALL_MS) throw new Error("voice_audio_backpressure");
+          await new Promise((resolve) => setTimeout(resolve, 20));
+        }
+        if (current.abort.signal.aborted || current.done || closed || client.readyState !== 1) return;
         const chunk = audio.subarray(offset, offset + CHUNK_BYTES);
         current.outputMs += chunk.length / BYTES_PER_MS;
         send({ type: "response.output_audio.delta", response_id: current.id, item_id: current.itemId, output_index: 0, content_index: 0, delta: chunk.toString("base64") });
+        sentAt = Date.now();
       }
     };
     const respond = async (text, origin, key, input) => {
@@ -210,7 +263,8 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
       if (state.utterance?.text && !state.utterance.silent) { lastReply = state.utterance.key; speak(state.utterance.text, "turn", state.utterance.key, input); }
     };
     const userItem = (id, content) => send({ type: "conversation.item.done", item: { id, object: "realtime.item", type: "message", role: "user", status: "completed", content: [content] } });
-    const commit = async ({ endpointed = false } = {}) => {
+    const commit = async () => {
+      if (closed) return;
       // A commit with no samples still has a client waiting in transcribing.
       // Returning here never completes that take, so the composer stays on 转写中.
       if (!bytes) {
@@ -219,9 +273,10 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
         send({ type: "conversation.item.input_audio_transcription.completed", item_id: id, content_index: 0, transcript: "" });
         return;
       }
-      // Server VAD keeps listening while a turn is processed; the next endpoint waits for it.
-      if (busy && endpointed) { pendingCommit = true; return; }
-      if (busy) fail("turn_busy");
+      // The previous turn is still being transcribed or submitted. The mic is
+      // shared and the client cannot know that, so queue this take instead of
+      // rejecting it; the composer would otherwise see a hard turn_busy.
+      if (busy) { pendingCommit = true; return; }
       const input = Buffer.concat(chunks), id = itemId || `item_${randomUUID()}`, ms = input.length / BYTES_PER_MS, opened = stream;
       stream = null; reset(); scope.voiceInputActive = false; busy = true;
       send({ type: "input_audio_buffer.committed", item_id: id, previous_item_id: null });
@@ -247,20 +302,33 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
       } catch (cause) { if (!closed && epoch === generation) report(cause); }
       finally {
         busy = false;
-        if (pendingCommit) { pendingCommit = false; void commit({ endpointed: true }).catch(report); }
+        if (pendingCommit) { pendingCommit = false; void commit().catch(report); }
+        else drainTyped();
       }
     };
+    // Typed text that arrives while a take is in flight waits its turn instead
+    // of being rejected: on a shared link the client cannot tell it is early.
+    const typedQueue = [];
+    const drainTyped = () => {
+      if (closed || busy || !typedQueue.length) return;
+      const next = typedQueue.shift();
+      void runTyped(next).catch(report);
+    };
+    const runTyped = async ({ id, text }) => {
+      if (closed) return;
+      busy = true;
+      userItem(id, { type: "input_text", text });
+      try { await submit(text, id, generation, 0); }
+      finally { busy = false; drainTyped(); }
+    };
     const typed = async (event) => {
       if (type !== "realtime") fail("unsupported_parameter");
       const item = only(event.item, ["id", "type", "role", "content"]);
       const content = Array.isArray(item.content) && item.content.length === 1 ? only(item.content[0], ["type", "text"]) : fail("unsupported_parameter");
       if (item.type !== "message" || item.role !== "user" || content.type !== "input_text" || typeof content.text !== "string" || !content.text.trim() || content.text.length > 16000) fail("unsupported_parameter");
-      if (busy) fail("turn_busy");
-      busy = true;
       const id = typeof item.id === "string" && item.id ? item.id.slice(0, 128) : `item_${randomUUID()}`;
-      userItem(id, { type: "input_text", text: content.text });
-      try { await submit(content.text, id, generation, 0); }
-      finally { busy = false; }
+      if (busy) { if (typedQueue.length >= 8) fail("turn_busy"); typedQueue.push({ id, text: content.text }); return; }
+      await runTyped({ id, text: content.text });
     };
     const startStream = () => {
       const current = { queue: [], live: null, id: itemId };
@@ -278,7 +346,8 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
     };
     const append = (audio) => {
       if (awaitingPlayback && !bargeActive()) fail("waiting_for_playback");
-      if (busy && !automatic) fail("turn_busy");
+      // Audio that arrives while the previous take is being transcribed belongs
+      // to the next turn; keep it and let that commit queue behind the first one.
       if (typeof audio !== "string" || audio.length > 64000 || !/^[A-Za-z0-9+/]*={0,2}$/.test(audio)) fail("unsupported_audio_format");
       const chunk = Buffer.from(audio, "base64");
       if (chunk.length % 2) fail("unsupported_audio_format");
@@ -293,7 +362,7 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
       if (automatic && bargeActive() && response && !response.suspended && speechMs >= BARGE_IN_MS) suspend(response);
       if (automatic && endpoint.push(1, rms, chunk.length / BYTES_PER_MS)) {
         send({ type: "input_audio_buffer.speech_stopped", audio_end_ms: Math.round(totalMs), item_id: itemId });
-        void commit({ endpointed: true }).catch(report);
+        void commit().catch(report);
       }
     };
     const suspend = (current) => {
@@ -393,14 +462,17 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
           // The client has stopped listening. A reply that already finished must
           // not keep the next utterance behind waiting_for_playback.
           awaitingPlayback = false;
+          clearAckWatch();
           if (busy && turn) generation++;
           cancel("cancelled");
           return;
         case "lares.playback.progress":
           acknowledges = true;
           if (typeof event.item_id === "string" && Number.isFinite(event.played_ms) && event.played_ms >= 0) played.set(event.item_id, event.played_ms);
+          // Progress is the client proving it is still rendering the reply.
+          watchAck();
           return;
-        case "lares.playback.completed": acknowledges = true; awaitingPlayback = false; return;
+        case "lares.playback.completed": acknowledges = true; awaitingPlayback = false; clearAckWatch(); return;
         case "lares.task.cancel": {
           if (typeof event.task_id !== "string" || !tasks.has(event.task_id)) fail("task_not_cancellable");
           if (await service.withdraw(scope, event.task_id) === "not_cancellable") fail("task_not_cancellable");
@@ -419,7 +491,7 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
 
     const close = () => {
       if (closed) return;
-      closed = true; response?.abort.abort(); generation++; reset(); clearInterval(heartbeat); clearInterval(results); clearTimeout(idle);
+      closed = true; response?.abort.abort(); generation++; reset(); clearAckWatch(); clearInterval(heartbeat); clearInterval(results); clearTimeout(idle);
       unbind(); clients.delete(client); client.close();
       void Promise.resolve(port?.stop()).catch(() => {});
       if (scope.realtimeSocket === client) scope.realtimeSocket = null;

package/voice/panel.js

@@ -1,6 +1,18 @@
 import { setVoiceActivity } from "./activity.js";
 import { DICTATION_PRESETS } from "./dictation.js";
 
+/** Some mobile webviews lack AbortSignal.any/timeout; the caller signal still cancels. */
+function budgetedSignal(signal, ms) {
+  const signals = [signal];
+  if (typeof AbortSignal?.timeout === "function") {
+    try { signals.push(AbortSignal.timeout(ms)); } catch { /* caller signal only */ }
+  }
+  if (signals.length > 1 && typeof AbortSignal.any === "function") {
+    try { return AbortSignal.any(signals); } catch { /* caller signal only */ }
+  }
+  return signal;
+}
+
 /** The panel owns drafts and turn policy; adapters only supply settings, audio and insertion ports. */
 export function createVoicePanel({ create, complete, loadConfig = async () => ({}), process = async ({ text }) => text, onSession = () => {}, manualTurns = true, inlineDictation = false, prepareInput = () => null, armOutput = () => {} }) {
   let state = { visible: false, inputActive: false, previewVisible: false, mode: "single", sessionId: null, raw: "", draft: "", edited: false, preset: "raw", stage: "idle", snapshot: null, busy: false, error: null, readAloudError: null, device: "", levels: [], startedAt: null, elapsedMs: 0, holding: false, cancelArmed: false };
@@ -39,7 +51,7 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     if (!DICTATION_PRESETS.includes(preset)) throw new Error("voice_config_invalid");
     cancelProcessing(); const abort = processing = new AbortController(); const token = generation;
     emit({ preset, stage: "processing", error: null });
-    const signal = AbortSignal.any([abort.signal, AbortSignal.timeout(45_000)]);
+    const signal = budgetedSignal(abort.signal, 45_000);
     let interrupted;
     const cancellation = new Promise((_, reject) => { interrupted = () => reject(signal.reason); signal.addEventListener("abort", interrupted, { once: true }); });
     try {

package/voice/pcm-player.js

@@ -3,6 +3,21 @@ import { pcmSamples } from "./realtime-audio.js";
 
 let primed = null;
 const worklets = new WeakMap();
+let watchingVisibility = false;
+
+/** iOS/macOS suspend the page's context on a call, the lock screen or a device switch. */
+function resumeIfInterrupted(context) {
+  if (!context || context.state === "closed" || context.state === "running") return;
+  void context.resume?.().catch(() => {});
+}
+
+function watchVisibility() {
+  if (watchingVisibility || typeof document === "undefined" || !document.addEventListener) return;
+  watchingVisibility = true;
+  document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState === "visible") resumeIfInterrupted(primed);
+  });
+}
 
 function ensureWorklet(ctx) {
   const pending = worklets.get(ctx);
@@ -29,6 +44,41 @@ export function primePlaybackContext(Context = globalThis.AudioContext || global
 
 export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () => {}, context: Context = globalThis.AudioContext || globalThis.webkitAudioContext } = {}) {
   let context, node, resolve, reject, played = 0, generation = 0, pendingByte = null, failed = null, paused = false, owned = false;
+  /**
+   * The page shares one primed context. iOS interrupts it (a call, the lock
+   * screen) and it never resumes on its own, so a reply that starts after that
+   * gets a fresh context instead of a silent failure.
+   */
+  const openContext = async (shared) => {
+    watchVisibility();
+    if (shared) {
+      shared.addEventListener?.("statechange", () => resumeIfInterrupted(shared));
+      try {
+        await ensureWorklet(shared);
+        await shared.resume?.();
+        if (!shared.state || shared.state === "running") {
+          owned = false; context = shared;
+          return { opened: shared, shared: true };
+        }
+      } catch { /* replaced below */ }
+      worklets.delete(shared);
+      if (primed === shared) primed = null;
+    }
+    const fresh = new Context();
+    owned = true;
+    fresh.addEventListener?.("statechange", () => resumeIfInterrupted(fresh));
+    try {
+      await ensureWorklet(fresh);
+      await fresh.resume?.();
+      if (fresh.state && fresh.state !== "running") throw new Error("voice_playback_failed");
+    } catch (error) {
+      owned = false;
+      if (fresh.state !== "closed") void fresh.close?.().catch(() => {});
+      throw error;
+    }
+    context = fresh;
+    return { opened: fresh, shared: false };
+  };
   const stop = () => {
     generation++; paused = false; node?.disconnect(); if (node) node.port.onmessage = null; node = null;
     const closing = owned ? context : null;
@@ -42,17 +92,14 @@ export function createPcmStreamPlayer({ onProgress = () => {}, onMetric = () =>
       if (!Context || channels !== 1 || encoding !== "pcm_s16le" || !Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new Error("voice_audio_format");
       const epoch = generation;
       const shared = primed && primed.state !== "closed" ? primed : null;
-      owned = !shared;
-      context = shared || new Context(); const opened = context;
+      let opened;
       try {
-        await ensureWorklet(opened);
-        await opened.resume?.();
+        ({ opened } = await openContext(shared));
         if (epoch !== generation) throw new Error("voice_cancelled");
-        if (opened.state && opened.state !== "running") throw new Error("voice_playback_failed");
-        onMetric({ stage: "playback_context", state: opened.state || "unknown", shared: Boolean(shared) });
+        onMetric({ stage: "playback_context", state: opened.state || "unknown", shared: Boolean(shared && opened === shared) });
       } catch (error) {
-        onMetric({ stage: "playback_context", state: opened.state || "missing", shared: Boolean(shared), code: error?.message || "voice_playback_failed" });
-        if (owned && opened.state !== "closed") void opened.close?.().catch(() => {});
+        onMetric({ stage: "playback_context", state: context?.state || "missing", shared: Boolean(shared), code: error?.message || "voice_playback_failed" });
+        if (owned && context && context.state !== "closed") void context.close?.().catch(() => {});
         owned = false; context = null;
         throw error;
       }

package/voice/presentation.js

@@ -38,6 +38,17 @@ export function voiceCallFailure(view) {
   return { code: ui.error, action: recoverable ? "resume" : "restart" };
 }
 
+/**
+ * A voice call that is still playing keeps one strip at the composer until it
+ * ends: status plus the control that stops it. The hold button is not that
+ * strip. A chat readout stays on the assistant row that is being read.
+ */
+export function voicePlaybackChrome(view) {
+  const playback = view?.snapshot?.playback;
+  if (!playback || playback === "idle") return null;
+  return { status: voicePanelPresentation(view).status, stop: "call", stopLabel: "panel.close" };
+}
+
 /** Shared inline labels; clients own focus, positioning and the timer tick. */
 export function voiceInputPresentation(view, now = Date.now()) {
   const ui = voicePanelPresentation(view);

package/voice/protocol-client.js

@@ -1,10 +1,18 @@
 /** Transport-neutral `lares-realtime-v1` client: the caller obtains an authenticated socket. */
 export function createVoiceProtocolClient(socket, { onEvent = () => {}, onClose = () => {} } = {}) {
+  // A command that does not reach the host fails the take. Progress ticks are
+  // observations from the audio callback: drop them when the socket cannot take
+  // them, and never throw. Completion, cancel and truncate are different: they
+  // are what lets the host speak the next reply. Dropping them leaves the call
+  // open and every later answer silent.
+  const open = () => socket.readyState === 1 && socket.bufferedAmount <= 1024 * 1024;
   const send = (event) => {
     if (socket.readyState !== 1) throw new Error("voice_disconnected");
     if (socket.bufferedAmount > 1024 * 1024) throw new Error("voice_audio_backpressure");
     socket.send(JSON.stringify(event));
   };
+  const observe = (event) => { if (open()) socket.send(JSON.stringify(event)); };
+  const release = (event) => { if (socket.readyState === 1) socket.send(JSON.stringify(event)); };
   const message = (event) => {
     let value;
     try { value = JSON.parse(String(event.data)); } catch { onEvent({ type: "error", error: { code: "voice_protocol" } }); return; }
@@ -24,10 +32,10 @@ export function createVoiceProtocolClient(socket, { onEvent = () => {}, onClose
     commit() { send({ type: "input_audio_buffer.commit" }); },
     discard() { send({ type: "input_audio_buffer.clear" }); },
     say(text) { send({ type: "conversation.item.create", item: { type: "message", role: "user", content: [{ type: "input_text", text }] } }); },
-    playbackProgress(itemId, playedMs) { send({ type: "lares.playback.progress", item_id: itemId, played_ms: playedMs }); },
-    playbackCompleted(itemId = null) { send({ type: "lares.playback.completed", item_id: itemId }); },
-    stopOutput() { send({ type: "response.cancel" }); },
-    truncate(itemId, audioEndMs) { send({ type: "conversation.item.truncate", item_id: itemId, content_index: 0, audio_end_ms: Math.max(0, Math.round(audioEndMs)) }); },
+    playbackProgress(itemId, playedMs) { observe({ type: "lares.playback.progress", item_id: itemId, played_ms: playedMs }); },
+    playbackCompleted(itemId = null) { release({ type: "lares.playback.completed", item_id: itemId }); },
+    stopOutput() { release({ type: "response.cancel" }); },
+    truncate(itemId, audioEndMs) { release({ type: "conversation.item.truncate", item_id: itemId, content_index: 0, audio_end_ms: Math.max(0, Math.round(audioEndMs)) }); },
     setOutput(audio) { send({ type: "session.update", session: { output_modalities: [audio ? "audio" : "text"] } }); },
     setBusyTurn(mode) { send({ type: "session.update", session: { lares: { busy_turn: mode === "steer" ? "steer" : "queue" } } }); },
     deviceInput(active) { send({ type: active ? "lares.device.input.resume" : "lares.device.input.pause" }); },

package/voice/service.js

@@ -59,8 +59,13 @@ export function voiceScope(id, owner = "", device = "headset") {
   if (!/^[a-zA-Z0-9_-]{8,128}$/.test(id)) throw new VoiceError("voice_session_invalid", 400, "invalid voice connection");
   const key = `${owner}:${id}`;
   for (const [other, scope] of scopes) {
-    if (Date.now() - scope.seen > 120_000 && !deviceLease.owns(scope)) {
+    // A socket that is still open is a connected client, even when it has made
+    // no HTTP call for two minutes. Its own recovery timer retires it; evicting
+    // it here would close the session under a call that is merely paused.
+    const liveSocket = scope.realtimeSocket && scope.realtimeSocket.readyState === 1;
+    if (Date.now() - scope.seen > 120_000 && !deviceLease.owns(scope) && !liveSocket) {
       scopes.delete(other);
+      scope.active = false;
       void scope.duplex.interrupt().catch(() => {});
       scope.capture?.stop(true);
       void scope.session?.close();
@@ -312,9 +317,17 @@ export async function speakFromConfig(text, options = {}) {
   const deadline = readout.segmenter.deadline;
   if (deadline !== null) {
     await new Promise((resolve, reject) => {
+      // setTimeout can fire before Date.now() reaches the segmenter deadline.
+      // Flushing early drops the pending list item and reports zero sentences.
+      let timer;
       const cleanup = () => { clearTimeout(timer); readout.signal.removeEventListener("abort", cancel); };
       const cancel = () => { cleanup(); reject(cancelledSpeech()); };
-      const timer = setTimeout(() => { cleanup(); resolve(); }, Math.max(0, deadline - Date.now()));
+      const tick = () => {
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) { cleanup(); resolve(); return; }
+        timer = setTimeout(tick, remaining);
+      };
+      timer = setTimeout(tick, Math.max(0, deadline - Date.now()));
       readout.signal.addEventListener("abort", cancel, { once: true });
       if (readout.signal.aborted) cancel();
     });
@@ -390,6 +403,9 @@ async function readAloud(readout, model, voice, lease, options) {
   let player;
   const abortPlayer = () => player?.abort?.();
   lease.signal.addEventListener("abort", abortPlayer);
+  // A keyed readout is consumed sentence by sentence; only the whole-answer
+  // call needs the full PCM copy.
+  const collect = !options.key;
   const pcm = [];
   let sentence = [];
   let streamed = false;
@@ -414,7 +430,7 @@ async function readAloud(readout, model, voice, lease, options) {
       readout.firstAudio = true;
       if (options.scope) writeReport({ scope: "voice", event: "metric", voiceId: options.scope.id, stage: "synthesis_first_audio", durationMs: Date.now() - readout.createdAt, queueDepth: readout.segments.length });
     }
-    pcm.push(chunk);
+    if (collect) pcm.push(chunk);
     sentence.push(chunk);
     if (!lease.active()) return;
     opening ??= openPlayback();

package/voice/speech.js

@@ -192,7 +192,13 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
   let lastKey = null;
   let silencedKey = null;
   const consumed = new Set();
-  const mark = (set, key) => { if (key != null) set.add(key); };
+  // One page reads many turns; keep the names bounded without re-reading any.
+  const REMEMBERED = 256;
+  const mark = (_set, key) => {
+    if (key == null) return;
+    consumed.add(key);
+    if (consumed.size > REMEMBERED) consumed.delete(consumed.values().next().value);
+  };
 
   const emitOutput = value => {
     if (value || readoutState.getSnapshot()?.key === lastKey || onOutput !== readoutState.publish) onOutput(value);

package/voice/stream-client.js

@@ -105,6 +105,9 @@ export async function startTranscriptionStream(options) {
   const connection = await openAudioStream({ ...options, operation: "stt" });
   if (!connection) return null;
   let final = null, finished = false, completed = false, failed = false, finishAt = 0, resolve, reject;
+  // The Host owns the ASR request; this bound only stops this client waiting.
+  // Falling back to the recorded blob is what keeps the take usable.
+  const FINAL_TIMEOUT_MS = 60_000;
   const result = new Promise((yes, no) => { resolve = yes; reject = no; });
   void result.catch(() => {});
   let readyResolve, readyReject;
@@ -134,8 +137,18 @@ export async function startTranscriptionStream(options) {
   if (options.signal?.aborted) fail(new Error("voice_cancelled"));
   await ready;
   return {
+    // A committed take is final on the Host; a late or empty result must not be
+    // re-sent as a recording. This socket only transcribes, so replaying is safe.
+    get committed() { return finished; },
+    get replayable() { return true; },
     write(bytes) { if (finished || connection.readyState !== 1 || connection.bufferedAmount > 256 * 1024) throw new Error("voice_audio_backpressure"); connection.send(bytes); },
-    async finish() { finishAt = Date.now(); finished = true; connection.send(JSON.stringify({ type: "finish" })); try { return await result; } finally { connection.close(); } },
+    async finish() {
+      finishAt = Date.now(); finished = true; connection.send(JSON.stringify({ type: "finish" }));
+      let timer;
+      const timeout = new Promise((_, no) => { timer = setTimeout(() => no(new Error("voice_asr_timeout")), FINAL_TIMEOUT_MS); });
+      try { return await Promise.race([result, timeout]); }
+      finally { clearTimeout(timer); connection.close(); }
+    },
     cancel() { fail(new Error("voice_cancelled")); },
   };
 }
@@ -170,6 +183,8 @@ export async function createStreamingCapture(stream, options) {
     };
     source.connect(node); node.connect(context.destination);
     return {
+      get committed() { return port.committed === true; },
+      get replayable() { return port.replayable !== false; },
       async finish() {
         try {
           await new Promise((resolve, reject) => { const timer = setTimeout(() => reject(new Error("voice_timeout")), 2000); flushed = () => { clearTimeout(timer); resolve(); }; node.port.postMessage({ type: "flush" }); });

package/voice/stream-gateway.js

@@ -10,7 +10,7 @@ import { routerGatewayUrl, routerAuthHeaders } from "../router/gateway.js";
 const fault = (code, status = 409) => new VoiceError(code, status, code);
 
 /** Single-use HTTP grants bind raw audio sockets to the authenticated Host scope. */
-export function createAudioStreamGateway({ config, models, replies, synthesize = synthesizeStream, env = process.env, metric = () => {} }) {
+export function createAudioStreamGateway({ config, models, replies, synthesize = synthesizeStream, env = process.env, metric = () => {}, playbackStallMs = 45_000 }) {
   const tickets = new Map(), clients = new Set();
   const synthesis = createSynthesisRuns({ synthesize, metric });
   const server = new WebSocketServer({ noServer: true, maxPayload: 96 * 1024, perMessageDeflate: false,
@@ -49,11 +49,18 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
         clients.add(client);
         const abort = new AbortController();
         let upstream = null, sentFrames = 0, playedFrames = 0, rate = 0, waiter = null, outputFormat = null;
-        let fileDone = null, pausedAt = 0, closing = false;
+        let fileDone = null, pausedAt = 0, closing = false, ttsKey = null;
         let received = 0, committed = false, outputStarted = false;
         const started = Date.now();
         const send = (value) => { if (client.readyState === 1) client.send(JSON.stringify(value)); };
-        const close = () => { if (closing) return; closing = true; abort.abort(); waiter?.(); fileDone?.(); clearTimeout(lifetime); upstream?.terminate(); clients.delete(client); client.close(); };
+        const close = () => {
+          if (closing) return;
+          closing = true; abort.abort(); waiter?.(); fileDone?.(); clearTimeout(lifetime); upstream?.terminate();
+          // A consumer that disappeared stops its synthesis instead of leaving
+          // the whole answer to be rendered with nobody listening.
+          if (ttsKey) synthesis.release(ttsKey);
+          clients.delete(client); client.close();
+        };
         const error = (cause) => {
           const code = cause?.code || "voice_stream_failed";
           if (grant.operation === "tts" && code !== "voice_cancelled") metric({ stage: "playback_stop", voiceId: grant.scope.id, code, sentFrames, playedFrames });
@@ -104,6 +111,7 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
           upstream.on("close", () => { send({ type: "eof" }); close(); });
         } else {
           const key = grant.replySource ? utteranceKey(grant.replySource) : `text:${grant.text}`;
+          ttsKey = key;
           const run = synthesis.attach(key, (signal) => grant.reply ? grant.reply(signal) : (async function* text() {
             const parts = speechSegments(grant.text, { done: true });
             for (let index = 0; index < parts.length; index += 1) yield { text: parts[index], index };
@@ -137,7 +145,14 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
                 for (let offset = 0; offset < event.chunk.length; offset += 16384) {
                   while (pausedAt || sentFrames - playedFrames > rate * 2 || client.bufferedAmount > 128 * 1024) {
                     if (!reportedWait) { reportedWait = true; metric({ stage: "playback_wait", voiceId: grant.scope.id, sentFrames, playedFrames, paused: Boolean(pausedAt) }); }
-                    await new Promise((resolve, reject) => { const timer = setTimeout(() => { waiter = null; reject(fault(pausedAt ? "voice_interruption_timeout" : "voice_audio_backpressure")); }, pausedAt ? Math.max(1, 10000 - (Date.now() - pausedAt)) : 10000); waiter = () => { clearTimeout(timer); resolve(); }; });
+                    // A device switch or a locked screen can stop playout for a
+                    // while without the client being gone. Wait for it to come
+                    // back instead of ending the answer after ten seconds.
+                    await new Promise((resolve, reject) => {
+                      const limit = pausedAt ? Math.max(1, 10_000 - (Date.now() - pausedAt)) : playbackStallMs;
+                      const timer = setTimeout(() => { waiter = null; reject(fault(pausedAt ? "voice_interruption_timeout" : "voice_audio_backpressure")); }, limit);
+                      waiter = () => { clearTimeout(timer); resolve(); };
+                    });
                     if (abort.signal.aborted || client.readyState !== 1) throw fault("voice_cancelled");
                   }
                   if (client.readyState !== 1) throw fault("voice_cancelled");

package/voice/synthesis-run.js

@@ -79,7 +79,10 @@ export function createSynthesisRuns({ synthesize, metric = () => {} }) {
   }
 
   return {
-    /** `open` is used only for the first subscriber of `key`. */
+    /**
+     * `open` is used only for the first subscriber of `key`; every other observer
+     * of the same answer shares that one synthesis.
+     */
     attach(key, open, request) {
       let run = runs.get(key);
       if (!run) {
@@ -89,6 +92,13 @@ export function createSynthesisRuns({ synthesize, metric = () => {} }) {
       }
       return run;
     },
+    /** Dropping the last consumer stops synthesis instead of draining the whole answer. */
+    release(key) {
+      const run = key && runs.get(key);
+      if (!run) return;
+      run.cancel();
+      if (runs.get(key) === run) runs.delete(key);
+    },
     cancel(key) { if (key) runs.get(key)?.cancel(); },
     close() { for (const run of runs.values()) run.cancel(); runs.clear(); },
   };