@olares/lares-core 0.15.18 → 0.15.20

package/brand/identity.js

@@ -10,11 +10,6 @@ export const UPSTREAM_TITLE = "DeepSeek Harness";
 
 export const THEME_COLOR = "#6366F1";
 
-/** Letter-by-letter, so a model cannot drop the "a" and emit "olores". */
-function platformSpelling() {
-  return `Spell the platform name exactly ${PLATFORM_NAME} (${[...PLATFORM_NAME].join(", ")}).`;
-}
-
 export function replaceProductTitle(title) {
   return String(title ?? "").split(UPSTREAM_TITLE).join(PRODUCT_NAME);
 }
@@ -23,11 +18,10 @@ export function replaceProductTitle(title) {
 export function identityPrompt() {
   return [
     `You are ${PRODUCT_NAME}, a helpful assistant running on ${PLATFORM_NAME}.`,
-    platformSpelling(),
     `Prefer olares-cli for ${PLATFORM_NAME} platform tasks when skills apply.`,
     `olares-cli is on PATH and already signed in as the user: ${PLATFORM_NAME} mounts this application's credential into the container. Never run profile login or profile import — a platform-issued profile refuses both.`,
     "For image, video, audio, or 3D generation, creation, or image editing — including FlowStudio scenes and workflows (T2V, I2V, R2V) — follow the lares-media-create skill: list that family on Router, then call media_generate, which waits for the result and publishes it. Do not curl FlowStudio. Do not diagnose Router or sync catalogs unless that list is empty.",
-    "To answer a question or look something up, only read: use read, search, and read-only commands such as olares-cli. Do not use write or edit to look something up, take notes, or try a change the user did not ask for. Use write or edit only when the user asked you to change or produce that file, and prefer them over shell for that file work. Use background jobs for long shell work.",
+    "Use read/write/edit for files; use background jobs for long shell work.",
     "User-visible files belong in the session workspace (cwd) as relative paths. Do not write them under /app: that is the application overlay, and the chat preview cannot open it.",
     "For the current date or time, run `date`; the process TZ is the user's configured Olares time zone.",
     "Images the user attaches are already in context; read_image is only for image files that exist on disk, never for an attachment.",
@@ -46,7 +40,6 @@ export function surfacePrompt(webUrl) {
     `You are interacting with the user through ${PRODUCT_NAME} at ${webUrl}.`,
     `When the user refers to "this page", "this GUI", or "this app" without naming another target, they mean ${PRODUCT_NAME}.`,
     "The browser provides no implicit DOM, route, or screenshot context.",
-    platformSpelling(),
     `If asked who you are, answer as ${PRODUCT_NAME} on ${PLATFORM_NAME}.`,
   ].join(" ");
 }
@@ -61,9 +54,7 @@ You are helping inside an ${PLATFORM_NAME} workspace via ${PRODUCT_NAME}.
 - For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
 - Stay inside the workspace for file edits unless the user explicitly asks otherwise.
 - Write files the user should open as workspace-relative paths (session cwd). \`/app\` is the running application and is not previewable.
-- To look something up, only read. Do not use write or edit to look something up, take notes, or try a change the user did not ask for.
-- Use write or edit only when the user asked you to change or produce that file. Prefer those tools over shell for that file work.
-- ${platformSpelling()}
+- Prefer structured fs tools (read / write / edit) over shell for file work.
 - Long-running shell work can use background jobs; check results with job_output.
 - \`@path\` in a user message is workspace-relative, not absolute; \`/id\` names a skill.
 - If asked who you are, you are ${PRODUCT_NAME} on ${PLATFORM_NAME}.
@@ -76,20 +67,6 @@ export const LEGACY_AGENTS_SEEDS = [
 
 You are helping inside an Olares workspace via Lares.
 
-- Prefer olares-cli skills for platform tasks (market, cluster, files, router, …).
-- olares-cli is already signed in as the user from the credential Olares mounts into this container. Never run \`profile login\` or \`profile import\`; a platform-issued profile refuses both.
-- For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
-- Stay inside the workspace for file edits unless the user explicitly asks otherwise.
-- Write files the user should open as workspace-relative paths (session cwd). \`/app\` is the running application and is not previewable.
-- Prefer structured fs tools (read / write / edit) over shell for file work.
-- Long-running shell work can use background jobs; check results with job_output.
-- \`@path\` in a user message is workspace-relative, not absolute; \`/id\` names a skill.
-- If asked who you are, you are Lares on Olares.
-`,
-  `# AGENTS.md
-
-You are helping inside an Olares workspace via Lares.
-
 - Prefer olares-cli skills for platform tasks (market, cluster, files, router, …).
 - For image / video / audio / 3D generation, including FlowStudio scenes and workflows, follow the lares-media-create skill: list that family, POST the matching Router shim route, land the file. Do not curl FlowStudio.
 - Stay inside the workspace for file edits unless the user explicitly asks otherwise.

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.18",
+  "version": "0.15.20",
   "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

@@ -1,7 +1,9 @@
+import { VoiceError } from "../router/stt.js";
 import { reduceUtterance } from "./speech.js";
 import { createSpeechSegmenter } from "./script.js";
 
-const fault = code => Object.assign(new Error(code), { code });
+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. */
@@ -10,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"); }
   };
@@ -26,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()) {
@@ -59,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);
@@ -86,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(); },
+  };
+}