@olares/lares-core 0.15.19 → 0.15.21

package/i18n/voice.js

@@ -140,6 +140,7 @@ export const ZH = {
   "error.voice_tts_unavailable": "没有可用的语音播报模型，请先在语音设置里安装",
   "error.voice_speak_disabled": "语音播报是关着的",
   "error.voice_speak_failed": "语音播报失败，请重试",
+  "error.voice_playback_failed": "语音播报失败，请重试",
   "error.voice_speak_timeout": "语音播报超时，请重试",
   "error.voice_speak_unready": "当前不能保存语音播报开关",
   "error.voice_gpu_failed": "切换显卡模式失败（{detail}）。可以点重试；仍然失败，请到 Olares「设置 → GPU」查看显卡状态",
@@ -423,6 +424,7 @@ export const EN = {
   "error.voice_tts_unavailable": "No speech model is available. Install one in voice settings first",
   "error.voice_speak_disabled": "Speech playback is off",
   "error.voice_speak_failed": "Couldn't speak the answer, please retry",
+  "error.voice_playback_failed": "Couldn't speak the answer, please retry",
   "error.voice_speak_timeout": "Speech timed out, please retry",
   "error.voice_speak_unready": "Speech playback can't be saved right now",
   "error.voice_gpu_failed":

package/larepass/process-fold.js

@@ -221,7 +221,7 @@ export function transcriptBlocks(items, { running = false } = {}) {
       if (showHeader && !folded && memberSet.has(entry)) {
         blocks.push({
           kind: "fold",
-          key: `fold-${group.turn ?? `g${groupIndex}`}-${entry.index}`,
+          key: `fold-${group.turn ?? `g${groupIndex}`}-${entry.row?.key || entry.row?.id || entry.index}`,
           phase,
           foldable,
           reason,
@@ -232,7 +232,12 @@ export function transcriptBlocks(items, { running = false } = {}) {
         folded = true;
       }
       if (memberSet.has(entry) && showHeader) continue;
-      blocks.push({ kind: "row", key: `row-${entry.index}`, index: entry.index, row: entry.row });
+      blocks.push({
+        kind: "row",
+        key: entry.row?.key || entry.row?.id || `row-${entry.index}`,
+        index: entry.index,
+        row: entry.row,
+      });
     }
   });
   return blocks;

package/larepass/transcript.js

@@ -152,6 +152,9 @@ export function foldTranscript(entries) {
   };
 
   const putBlock = (turn, step, index, row) => {
+    // The block is one row for its whole life. Keying it by the event being
+    // folded makes the key change on every chunk, and the list remounts.
+    row.key = `block:${blockKey(turn, step, index)}:${row.type}`;
     const stored = upsert(items, blocks, blockKey(turn, step, index), tag(row));
     // The turn's readings belong under its closing reply, the row whose action
     // bar ends the turn on screen.

package/package.json

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

package/router/tts.js

@@ -89,6 +89,9 @@ export async function synthesizeStream(request, onChunk) {
     const signal = request.signal
       ? AbortSignal.any([request.signal, timeout])
       : timeout;
+    // A complete PCM body. The Qwen speech engine's streaming generator does not
+    // yield, so `stream: true` holds the model slot until the client times out
+    // and the readout never leaves "preparing".
     res = await fetch(`${routerShimBaseUrl()}/audio/speech`, {
       method: "POST",
       headers: { "content-type": "application/json", accept: "audio/l16,audio/wav" },
@@ -96,7 +99,6 @@ export async function synthesizeStream(request, onChunk) {
         model: request.model,
         input: text,
         response_format: "pcm",
-        stream: true,
         ...(request.voice ? { voice: request.voice } : {}),
       }),
       signal,
@@ -121,15 +123,17 @@ export async function synthesizeStream(request, onChunk) {
   if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new VoiceError("voice_audio_format", 502, "missing or invalid PCM sample rate");
   await request.onFormat?.({ sampleRate, channels: 1, encoding: "pcm_s16le" });
   const reader = res.body.getReader();
+  let bytes = 0;
   try {
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
-    if (value?.byteLength) await onChunk(Buffer.from(value));
+    if (value?.byteLength) { bytes += value.byteLength; await onChunk(Buffer.from(value)); }
   }
   } finally {
     await reader.cancel().catch(() => {});
     reader.releaseLock();
   }
+  if (!bytes) throw new VoiceError("voice_audio_format", 502, "speech returned no audio");
   return { streamed: true, sampleRate };
 }

package/voice/client.js

@@ -106,8 +106,15 @@ export async function postSpeak({ key, text, done, part }) {
   };
 }
 
-export async function postPlaybackStop(signal) {
-  const res = await fetch(`${API}/playback/stop`, { method: "POST", signal, headers: voiceHeaders() });
+export async function postPlaybackStop(source, signal) {
+  const body = source && typeof source === "object" && typeof source.addEventListener !== "function" ? source : undefined;
+  if (!body || typeof body.sessionId !== "string" || !Number.isSafeInteger(body.turn)) return { stopped: false };
+  const res = await fetch(`${API}/playback/stop`, {
+    method: "POST",
+    signal: body ? signal : source,
+    headers: { ...voiceHeaders(), ...(body ? { "content-type": "application/json" } : {}) },
+    body: body ? JSON.stringify({ sessionId: body.sessionId, turn: body.turn, step: body.step, attemptId: body.attemptId }) : undefined,
+  });
   if (!res.ok) throw new Error(String(res.status));
   return res.json();
 }

package/voice/conversation.js

@@ -34,7 +34,12 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
   const controller = createVoiceController({ voiceId, input, idleTimeoutMs, recoveryTimeoutMs, onExpired: () => stop(), onTranscript: onTranscript ? async (value) => { await onTranscript(value); if (!continuous) await stop(); } : null, metric: (event) => {
     metric(event);
     void call("/session/metric", { stage: event.stage, durationMs: event.durationMs }).catch(() => {});
-  }, output: { get canPause() { return playback.canPause === true; }, key: () => playback.key, pause: () => playback.pause?.(), resume: () => playback.resume?.(), async stop() { mute(lastUtterance, lastSessionId); playback.stop(); await call("/playback/stop", {}); } }, agent: {
+  }, output: { get canPause() { return playback.canPause === true; }, key: () => playback.key, pause: () => playback.pause?.(), resume: () => playback.resume?.(), async stop() {
+      const reply = lastUtterance;
+      playback.stop();
+      if (!reply || !Number.isFinite(reply.turn) || typeof lastSessionId !== "string") return;
+      await call("/playback/stop", { sessionId: lastSessionId, turn: reply.turn, step: reply.step, attemptId: reply.attemptId });
+    } }, agent: {
     lazy: true,
     create: async () => null,
     async submit({ text, requestId, signal }) {
@@ -67,7 +72,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       if (reserve) spokenKey = key;
       controller.observeAgent(Boolean(state.running), Boolean(reserve));
       if (!readAloud || reply?.silent) controller.observePlayback(false);
-      if (!turnMuted && readAloud && key !== mutedKey && reply) onReply({ ...reply, sessionId: state.sessionId, ...(device === "device" ? { source: { sessionId: state.sessionId, turn: reply.turn, step: reply.step, attemptId: reply.attemptId } } : {}), key: `${voiceId}:${state.sessionId}:${reply.key}` }, headers);
+      if (!turnMuted && readAloud && key !== mutedKey && reply) onReply({ ...reply, sessionId: state.sessionId, source: { sessionId: state.sessionId, turn: reply.turn, step: reply.step, attemptId: reply.attemptId }, key: `${voiceId}:${state.sessionId}:${reply.key}` }, headers);
     }
     if (device === "headset" && !state.running && !reading) {
       const audio = await call("/playback/status");
@@ -106,6 +111,13 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       clearTimeout(timer);
       const initial = onTranscript ? {} : await call("/session", { sessionId, readAloud, presentationSession, ...(preset ? { preset } : {}), ...(backend ? { backend } : {}) });
       if (!shouldStart()) { await stop(); return; }
+      // The answer already on screen belongs to the chat reader. Re-subscribing
+      // here attaches to a run that reader is about to cancel.
+      if (initial?.utterance && typeof initial.sessionId === "string") {
+        mute(initial.utterance, initial.sessionId);
+        mutedKey = `${initial.sessionId}:${initial.utterance.key}`;
+        spokenKey = mutedKey;
+      }
       await controller.start({ sessionId, continuous, manual, running: initial.running, shouldStart });
       controller.setOutputMuted(!readAloud);
       if (!onTranscript) void watch();

package/voice/duplex.js

@@ -5,13 +5,16 @@
 export function createDuplexCoordinator(stopPlayback = async () => {}) {
   let speech = null;
 
-  function beginSpeech(externalSignal) {
-    if (speech) {
+  function beginSpeech(externalSignal, id = "") {
+    if (speech && (!id || speech.id !== id)) {
       speech.controller.abort();
       void Promise.resolve(stopPlayback()).catch(() => {});
+      speech = null;
     }
+    if (speech && id && speech.id === id) return speech.pub;
     const controller = new AbortController();
     const lease = {
+      id,
       controller,
       active() {
         return speech === lease && !controller.signal.aborted;
@@ -20,6 +23,7 @@ export function createDuplexCoordinator(stopPlayback = async () => {}) {
         if (speech === lease) speech = null;
       },
     };
+    lease.pub = { signal: controller.signal, active: lease.active, finish: lease.finish };
     speech = lease;
     if (externalSignal) {
       const abort = () => {
@@ -30,10 +34,11 @@ export function createDuplexCoordinator(stopPlayback = async () => {}) {
       if (externalSignal.aborted) abort();
       else externalSignal.addEventListener("abort", abort, { once: true });
     }
-    return { signal: controller.signal, active: lease.active, finish: lease.finish };
+    return lease.pub;
   }
 
-  async function interrupt() {
+  async function interrupt(id = "") {
+    if (id && speech?.id !== id) return;
     const current = speech;
     speech = null;
     current?.controller.abort();

package/voice/reply-stream.js

@@ -12,7 +12,7 @@ export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segm
   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.claimed || row.error || !row.eligible && !row.done) return;
+    if (!row.subscribers || row.error || !row.eligible && !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 +28,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() });
+          segmenter: segmenterFactory(), ready: [], eligible: frame.speechEligible === true, utterance: null, next: 0, done: false, error: null, at: now(), listeners: new Set(), subscribers: 0 });
         return;
       }
       for (const row of rows.values()) {
@@ -61,10 +61,10 @@ export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segm
       await inspect(source.sessionId);
       const row = rows.get(identity(source));
       if (!row || source.attemptId && source.attemptId !== row.attemptId) throw fault("voice_reply_unavailable");
-      if (row.claimed) throw fault("voice_output_owned");
-      row.claimed = true; advance(row);
       return async function* segments(signal) {
         let index = 0;
+        row.subscribers += 1;
+        advance(row);
         try {
           while (!signal.aborted) {
             if (row.error) throw fault(row.error);
@@ -88,11 +88,17 @@ export function createReplyStreamRegistry({ inspect, owner, now = Date.now, segm
           }
           throw fault("voice_cancelled");
         } finally {
-          if (!row.done) fail(row, "voice_cancelled");
-          row.segmenter.reset();
+          row.subscribers -= 1;
         }
       };
     },
+    /** Ends this answer for every subscriber. A later turn is a different row. */
+    cancel(source) {
+      if (!source || typeof source.sessionId !== "string") return;
+      const row = rows.get(identity(source));
+      if (!row || row.done) return;
+      fail(row, "voice_cancelled");
+    },
     remove(sessionId) { for (const [key, row] of rows) if (row.sessionId === sessionId) { fail(row, "voice_session_closed"); rows.delete(key); } },
     close() { for (const row of rows.values()) fail(row, "voice_session_closed"); rows.clear(); },
   };

package/voice/service.js

@@ -22,6 +22,7 @@ import {
 } from "./session.js";
 import { createCaptureSession } from "./capture.js";
 import { createDuplexCoordinator } from "./duplex.js";
+import { utteranceKey } from "./synthesis-run.js";
 import { createDeviceLease } from "./lease.js";
 import { normalizeSttPcm } from "./pcm.js";
 import { gapAfter, createSpeechSegmenter } from "./script.js";
@@ -486,8 +487,8 @@ async function readAloud(readout, model, voice, lease, options) {
 
 export function playbackStatus(scope) { return { playing: (scope?.duplex ?? duplex).isSpeaking() }; }
 
-export function interruptSpeech(scope) {
-  return (scope?.duplex ?? duplex).interrupt();
+export function interruptSpeech(scope, source) {
+  return (scope?.duplex ?? duplex).interrupt(utteranceKey(source));
 }
 
 export function languageForTranscribe(requestedLanguage, configLanguage) {

package/voice/speech.js

@@ -192,9 +192,6 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
   let lastKey = null;
   let silencedKey = null;
   const consumed = new Set();
-  const mutedTurns = new Set();
-  let lastTurn = null;
-  const turnKey = (value) => Number.isFinite(value.turn) ? `${value.sessionId ?? ""}:${value.turn}` : null;
   const mark = (set, key) => { if (key != null) set.add(key); };
 
   const emitOutput = value => {
@@ -273,20 +270,20 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
       if (utterance.silent) {
         if (utterance.key !== lastKey || silencedKey === lastKey) return;
         silencedKey = lastKey;
+        const active = Boolean(current);
+        const source = current?.source;
         stop();
-        silence();
+        if (active) silence(source);
         return;
       }
       if (!utterance.text) return;
-      const identity = turnKey(utterance);
-      if (identity && mutedTurns.has(identity)) return;
       // A later tool call can invalidate uncommitted assistant text.
       if (stream && !utterance.done && !utterance.source) return;
       if (current?.key !== utterance.key) {
         if (consumed.has(utterance.key)) return;
-        if (current) { mark(mutedTurns, lastTurn); stop(); }
+        if (current) { const source = current.source; stop(); silence(source); }
         gen += 1;
-        lastKey = utterance.key; lastTurn = identity; mark(consumed, lastKey);
+        lastKey = utterance.key; mark(consumed, lastKey);
         current = {
           gen,
           abort: new AbortController(),
@@ -302,7 +299,7 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
         };
         current.identity = utterance;
         const run = current;
-        onState(true); emitOutput({ ...utterance, status: "preparing", stop: () => { mark(mutedTurns, lastTurn); stop(); silence(); } });
+        onState(true); emitOutput({ ...utterance, status: "preparing", stop: () => { mark(consumed, run.key); const source = run.source; stop(); silence(source); } });
         handOver(run);
         read(run).catch((err) => failed(run, err));
         return;
@@ -316,9 +313,11 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
     pause() { if (!current?.controls?.canPause) return false; current.controls.pause(); emitOutput({ key: current.key, status: "confirming" }); return true; },
     resume() { if (!current?.controls?.canPause) return false; current.controls.resume(); emitOutput({ key: current.key, status: "playing" }); return true; },
     stop() {
-      mark(mutedTurns, lastTurn);
+      if (!current) return;
+      mark(consumed, current.key);
+      const source = current.source;
       stop();
-      silence();
+      silence(source);
     },
   };
 }

package/voice/stream-client.js

@@ -33,19 +33,7 @@ function streamMetric(options, event) {
 export async function playAudioStream(options) {
   const started = Date.now();
   const connection = await openAudioStream({ ...options, operation: "tts" });
-  if (!connection) {
-    const response = await options.request("/api/lares/voice/speak", { method: "POST", headers: options.headers, signal: options.signal, body: { text: options.text } });
-    if (!response?.ok) throw new Error(response?.body?.error?.code || "voice_stream_failed");
-    if (response.body.sentences === 0) return true;
-    if (response.body.bluetooth === "played") return true;
-    if (options.source) throw new Error("voice_reply_unavailable");
-    const fallback = createBrowserPlayer();
-    options.controls?.({ canPause: true, pause: () => fallback.pause(), resume: () => fallback.resume() });
-    options.onStatus?.("playing");
-    const cancel = () => fallback.stop(); options.signal?.addEventListener("abort", cancel, { once: true });
-    try { if (!options.signal?.aborted) await fallback.play(wavBlob(response.body.audio)); } finally { options.signal?.removeEventListener("abort", cancel); fallback.stop(); }
-    return true;
-  }
+  if (!connection) throw new Error("voice_stream_failed");
   const file = createBrowserPlayer();
   const player = createPcmStreamPlayer({ onProgress: (frames) => { if (connection.readyState === 1) connection.send(JSON.stringify({ type: "progress", frames })); },
     onMetric: (event) => { if (event.stage === "playback_started") options.onStatus?.("playing"); streamMetric(options, { ...event, durationMs: Date.now() - started }); } });

package/voice/stream-gateway.js

@@ -1,5 +1,6 @@
 import { ttsVoiceForModel } from "./tts-voice.js";
 import { speechSegments } from "./script.js";
+import { createSynthesisRuns, utteranceKey } from "./synthesis-run.js";
 import { randomUUID } from "node:crypto";
 import { WebSocket, WebSocketServer } from "ws";
 import { synthesizeStream } from "../router/tts.js";
@@ -11,13 +12,14 @@ 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 = () => {} }) {
   const tickets = new Map(), clients = new Set();
+  const synthesis = createSynthesisRuns({ synthesize, metric });
   const server = new WebSocketServer({ noServer: true, maxPayload: 96 * 1024, perMessageDeflate: false,
     handleProtocols: (values) => values.has("lares-voice") ? "lares-voice" : false });
   return {
     async ticket(scope, body) {
-      if (scope.device !== "device") return { supported: false };
       if (!["tts", "stt"].includes(body.operation)) throw fault("voice_config_invalid", 400);
       const tts = body.operation === "tts";
+      if (!tts && scope.device !== "device") return { supported: false };
       const snapshot = structuredClone(scope.voiceConfig || config());
       if (tts && (scope.presentationSession || !scope.active)) {
         const current = config();
@@ -35,7 +37,7 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
       const reply = tts && body.source ? await replies?.bind(scope, body.source) : null;
       if (body.source && !reply) throw fault("voice_reply_unavailable");
       const ticket = randomUUID();
-      tickets.set(ticket, { scope, model: selected, operation: body.operation, text: body.text, reply,
+      tickets.set(ticket, { scope, model: selected, operation: body.operation, text: body.text, reply, replySource: body.source || null,
         config: snapshot, language: body.language || snapshot.language, expires: Date.now() + 30000 });
       return { supported: true, ticket };
     },
@@ -95,52 +97,68 @@ export function createAudioStreamGateway({ config, models, replies, synthesize =
           upstream.on("error", error);
           upstream.on("close", () => { send({ type: "eof" }); close(); });
         } else {
-          // A stop/new output owns the scope's existing duplex lease too.
-          const lease = grant.scope.duplex.beginSpeech(abort.signal);
-          const segments = grant.reply ? grant.reply(lease.signal) : speechSegments(grant.text, { done: true }).map((text, index) => ({ text, index }));
-          let carry = null;
-          const run = async () => { for await (const segment of segments) {
-          if (!lease.active()) throw fault("voice_cancelled");
-          const { text, index } = segment;
-          metric({ stage: "synthesis_segment", voiceId: grant.scope.id, index, chars: text.length, at: Date.now() });
-          send({ type: "segment", index, attemptId: segment.attemptId, startFrame: sentFrames });
-          const result = await synthesize({ text, model: grant.model, voice: ttsVoiceForModel(grant.config, grant.model), signal: lease.signal,
-            onFormat(format) { if (outputFormat && (format.channels !== outputFormat.channels || format.encoding !== outputFormat.encoding)) throw fault("voice_audio_format"); outputFormat = format; if (!rate) { rate = format.sampleRate; send({ type: "format", ...format }); } else if (rate !== format.sampleRate) throw fault("voice_audio_format"); },
-          }, async (chunk) => {
-            if (!lease.active()) throw fault("voice_cancelled");
-            if (!rate) throw fault("voice_audio_format", 502);
-            if (carry !== null) { chunk = Buffer.concat([Buffer.from([carry]), chunk]); carry = null; }
-            if (chunk.length % 2) { carry = chunk[chunk.length - 1]; chunk = chunk.subarray(0, -1); }
-            for (let offset = 0; offset < chunk.length; offset += 16384) {
-              while (pausedAt || sentFrames - playedFrames > rate * 2 || client.bufferedAmount > 128 * 1024) {
-                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(); }; });
-                if (!lease.active() || abort.signal.aborted) throw fault("voice_cancelled");
+          const key = grant.replySource ? utteranceKey(grant.replySource) : `text:${grant.text}`;
+          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 };
+          })(), { model: grant.model, voice: ttsVoiceForModel(grant.config, grant.model), voiceId: grant.scope.id });
+          let cursor = 0;
+          const unsub = run.subscribe(() => { waiter?.(); waiter = null; });
+          const waitFor = () => new Promise((resolve, reject) => {
+            if (abort.signal.aborted) { reject(fault("voice_cancelled")); return; }
+            const wake = () => { abort.signal.removeEventListener("abort", wake); waiter = null; if (abort.signal.aborted) reject(fault("voice_cancelled")); else resolve(); };
+            waiter = wake;
+            abort.signal.addEventListener("abort", wake, { once: true });
+          });
+          const pump = async () => {
+            while (!abort.signal.aborted) {
+              if (cursor >= run.events.length) {
+                if (run.settled) return;
+                await waitFor();
+                continue;
               }
-              if (!lease.active() || client.readyState !== 1) throw fault("voice_cancelled");
-              const part = chunk.subarray(offset, offset + 16384);
-              sentFrames += part.length / 2;
-              client.send(part);
-              if (!outputStarted) { outputStarted = true; metric({ stage: "synthesis_first_audio", voiceId: grant.scope.id, at: Date.now(), durationMs: Date.now() - started }); }
+              const event = run.events[cursor++];
+              if (event.type === "segment") send({ type: "segment", index: event.index, attemptId: event.attemptId, startFrame: sentFrames });
+              else if (event.type === "format") {
+                const format = event.format;
+                if (outputFormat && (format.channels !== outputFormat.channels || format.encoding !== outputFormat.encoding)) throw fault("voice_audio_format");
+                outputFormat = format;
+                if (!rate) { rate = format.sampleRate; send({ type: "format", ...format }); }
+                else if (rate !== format.sampleRate) throw fault("voice_audio_format");
+              } else if (event.type === "audio") {
+                if (!rate) throw fault("voice_audio_format", 502);
+                for (let offset = 0; offset < event.chunk.length; offset += 16384) {
+                  while (pausedAt || sentFrames - playedFrames > rate * 2 || client.bufferedAmount > 128 * 1024) {
+                    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(); }; });
+                    if (abort.signal.aborted || client.readyState !== 1) throw fault("voice_cancelled");
+                  }
+                  if (client.readyState !== 1) throw fault("voice_cancelled");
+                  const part = event.chunk.subarray(offset, offset + 16384);
+                  sentFrames += part.length / 2;
+                  client.send(part);
+                  if (!outputStarted) { outputStarted = true; metric({ stage: "synthesis_first_audio", voiceId: grant.scope.id, at: Date.now(), durationMs: Date.now() - started }); }
+                }
+              } else if (event.type === "segment.end") send({ type: "segment.end", index: event.index, endFrame: sentFrames });
+              else if (event.type === "file") {
+                if (rate) throw fault("voice_audio_format");
+                await new Promise((resolve, reject) => {
+                  const timer = setTimeout(() => reject(fault("voice_timeout")), 120000);
+                  fileDone = () => { clearTimeout(timer); resolve(); };
+                  send({ type: "file", audio: Buffer.from(event.audio).toString("base64") });
+                });
+              } else if (event.type === "done") { send({ type: "done" }); return; }
+              else if (event.type === "cancelled") throw fault("voice_cancelled");
+              else if (event.type === "error") throw fault(event.code || "voice_stream_failed");
             }
-          });
-          send({ type: "segment.end", index, endFrame: sentFrames });
-          if (carry !== null) throw fault("voice_audio_format");
-          if (!result.streamed) {
-            if (rate) throw fault("voice_audio_format");
-            await new Promise((resolve, reject) => {
-              const timer = setTimeout(() => reject(fault("voice_timeout")), 120000);
-              fileDone = () => { clearTimeout(timer); resolve(); };
-              send({ type: "file", audio: result.audio.toString("base64") });
-            });
-          }
-          if (!lease.active()) throw fault("voice_cancelled");
-          } };
-          const wake = () => { waiter?.(); waiter = null; fileDone?.(); fileDone = null; close(); };
-          lease.signal.addEventListener("abort", wake, { once: true });
-          void run().then(() => { if (!abort.signal.aborted) send({ type: "done" }); }).catch(error).finally(() => { lease.signal.removeEventListener("abort", wake); lease.finish(); });
+          };
+          void pump().catch((cause) => { if (!abort.signal.aborted) error(cause); }).finally(() => { unsub(); close(); });
         }
       });
     },
-    close() { tickets.clear(); for (const client of clients) client.terminate(); server.close(); },
+    cancel(source) {
+      synthesis.cancel(utteranceKey(source));
+      replies?.cancel?.(source);
+    },
+    close() { tickets.clear(); synthesis.close(); for (const client of clients) client.terminate(); server.close(); },
   };
 }

package/voice/synthesis-run.js

@@ -0,0 +1,95 @@
+/** One answer is `sessionId + turn + step + attemptId`. Listeners share that id. */
+export function utteranceKey(source) {
+  if (!source || typeof source.sessionId !== "string" || !Number.isSafeInteger(source.turn) || !Number.isSafeInteger(source.step)) return "";
+  return JSON.stringify([source.sessionId, source.turn, source.step, source.attemptId || ""]);
+}
+
+/**
+ * Synthesizes each answer once and fans the PCM out.
+ * Cancelling stops delivery immediately. The current response body is still
+ * read to the end before the next request is allowed to start, so a cut-off
+ * transfer cannot occupy the speech path for the following answer.
+ */
+export function createSynthesisRuns({ synthesize, metric = () => {} }) {
+  const runs = new Map();
+  let chain = Promise.resolve();
+  const enqueue = (task) => {
+    const next = chain.then(task, task);
+    chain = next.then(() => {}, () => {});
+    return next;
+  };
+
+  function start(key, open, request) {
+    const subscribers = new Set();
+    const events = [];
+    const abort = new AbortController();
+    let cancelled = false;
+    let settled = false;
+    let carry = null;
+    const notify = () => { for (const listener of subscribers) listener(); };
+    const push = (event) => { events.push(event); notify(); };
+    const finished = (async () => {
+      const segments = open(abort.signal);
+      try {
+        for await (const segment of segments) {
+          if (cancelled) break;
+          metric({ stage: "synthesis_segment", voiceId: request.voiceId, index: segment.index, chars: segment.text?.length || 0, at: Date.now() });
+          push({ type: "segment", index: segment.index, attemptId: segment.attemptId });
+          const result = await enqueue(async () => {
+            if (cancelled) return { skipped: true };
+            return synthesize({
+              text: segment.text,
+              model: request.model,
+              voice: request.voice,
+              onFormat(format) { push({ type: "format", format }); },
+            }, async (chunk) => {
+              if (cancelled || !chunk?.byteLength) return;
+              let buf = Buffer.from(chunk);
+              if (carry !== null) { buf = Buffer.concat([Buffer.from([carry]), buf]); carry = null; }
+              if (buf.length % 2) { carry = buf[buf.length - 1]; buf = buf.subarray(0, -1); }
+              if (!buf.length) return;
+              push({ type: "audio", chunk: buf });
+            });
+          });
+          if (cancelled || result?.skipped) break;
+          if (carry !== null) throw Object.assign(new Error("voice_audio_format"), { code: "voice_audio_format" });
+          push({ type: "segment.end", index: segment.index });
+          if (!result.streamed) {
+            push({ type: "file", audio: result.audio });
+            break;
+          }
+        }
+        push(cancelled ? { type: "cancelled" } : { type: "done" });
+      } catch (err) {
+        const code = err?.code || err?.message || "voice_failed";
+        push(cancelled || code === "voice_cancelled" ? { type: "cancelled" } : { type: "error", code });
+      } finally {
+        settled = true;
+        notify();
+        await segments?.return?.().catch(() => {});
+      }
+    })();
+    return {
+      events,
+      get settled() { return settled; },
+      subscribe(listener) { subscribers.add(listener); listener(); return () => subscribers.delete(listener); },
+      cancel() { if (cancelled || settled) return; cancelled = true; abort.abort(); notify(); },
+      finished,
+    };
+  }
+
+  return {
+    /** `open` is used only for the first subscriber of `key`. */
+    attach(key, open, request) {
+      let run = runs.get(key);
+      if (!run) {
+        run = start(key, open, request);
+        runs.set(key, run);
+        run.finished.finally(() => { if (runs.get(key) === run) runs.delete(key); });
+      }
+      return run;
+    },
+    cancel(key) { if (key) runs.get(key)?.cancel(); },
+    close() { for (const run of runs.values()) run.cancel(); runs.clear(); },
+  };
+}