@olares/lares-core 0.15.26 → 0.15.28

package/package.json

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

package/router/tts.js

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

package/voice/browser-capture.js

@@ -161,8 +161,19 @@ export function createVoiceCapture({
     emit("transcribing", { elapsed: took, error: "" });
     abort = new AbortController();
     try {
-      const text = String(await (streaming ? streaming.finish() : transcribe(blob, abort.signal)) ?? "").trim();
-      streaming = null;
+      let text = "";
+      if (streaming) {
+        const port = streaming;
+        streaming = null;
+        try {
+          text = String(await port.finish() ?? "").trim();
+        } catch (err) {
+          if (dead || abort.signal.aborted || cancel) return;
+          text = "";
+        }
+      }
+      // The socket can finish with nothing while the recording still has the words.
+      if (!text) text = String(await transcribe(blob, abort.signal) ?? "").trim();
       if (dead || cancel) return;
       if (!text) {
         trace("no-input", {});
@@ -204,6 +215,15 @@ export function createVoiceCapture({
       recorder.stop();
     } catch {
       scheduleFinish();
+      return;
+    }
+    // Some WebViews never fire onstop. The button already switched the UI to
+    // transcribing, so finish with the chunks collected so far instead of waiting.
+    if (!finishTimer) {
+      finishTimer = setTimeout(() => {
+        finishTimer = 0;
+        void finish();
+      }, 1000);
     }
   };
 

package/voice/lares-realtime-gateway.js

@@ -125,6 +125,7 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
       if (truncate) truncateTo(current, played.get(current.itemId) ?? 0);
     };
     const playOut = async (current, audio) => {
+      if (current.abort.signal.aborted || current.done || closed) return;
       if (headset) {
         if (!current.devicePlaying) { current.devicePlaying = true; send({ type: "lares.device.playback", playing: true }); }
         hostOutput = hostOutput.then(() => current.abort.signal.aborted ? undefined : port?.write(audio));
@@ -210,7 +211,14 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
     };
     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 } = {}) => {
-      if (!bytes) 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) {
+        const id = itemId || `item_${randomUUID()}`;
+        reset();
+        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");
@@ -382,6 +390,9 @@ export function createLaresRealtimeGateway({ service, config, transcribe, synthe
           speak(lastSpoken.text, lastSpoken.origin, lastSpoken.key, 0);
           return;
         case "response.cancel":
+          // The client has stopped listening. A reply that already finished must
+          // not keep the next utterance behind waiting_for_playback.
+          awaitingPlayback = false;
           if (busy && turn) generation++;
           cancel("cancelled");
           return;

package/voice/router-audio.js

@@ -56,7 +56,21 @@ export function createRouterAudio(config) {
       let chain = opened;
       return {
         write(pcm) { chain = chain.then(() => { if (socket.readyState === 1) socket.send(Buffer.from(convert(pcmSamples(pcm)))); }); chain.catch(() => {}); },
-        async finish() { await chain; socket.send(JSON.stringify({ type: "finish" })); try { return await final; } finally { socket.close(); } },
+        async finish() {
+          // Close the socket from a timer so a silent upstream cannot pin `final`:
+          // the close handler is what rejects it, and that close used to wait on `final`.
+          let timer;
+          try {
+            await chain;
+            if (socket.readyState !== 1) return null;
+            socket.send(JSON.stringify({ type: "finish" }));
+            timer = setTimeout(() => socket.close(), 12000);
+            return await final;
+          } finally {
+            clearTimeout(timer);
+            if (socket.readyState === 1) socket.close();
+          }
+        },
         cancel() { socket.terminate(); },
       };
     },

package/voice/speech-segmenter.js

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

package/voice/stream-client.js

@@ -49,7 +49,7 @@ export async function playAudioStream(options) {
     if (!progressNoted) { progressNoted = true; streamMetric(options, { stage: "playback_progress_sent", frames }); }
   },
     onMetric: (event) => { if (event.stage === "playback_started") options.onStatus?.("playing"); streamMetric(options, { ...event, durationMs: Date.now() - started }); } });
-  let chain = Promise.resolve(), complete = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
+  let chain = Promise.resolve(), complete = false, ending = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
   options.controls?.({
     get canPause() { return ready; },
     pause() { if (!ready || paused) return; paused = true; player.pause(); file.pause(); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "pause" })); },
@@ -69,10 +69,14 @@ export async function playAudioStream(options) {
       options.signal?.addEventListener("abort", cancelled, { once: true });
       connection.addEventListener("message", ({ data }) => {
         if (typeof data !== "string" && !firstReceived) { firstReceived = true; streamMetric(options, { stage: "playback_first_received", durationMs: Date.now() - started }); }
+        let event = null;
+        if (typeof data === "string") {
+          try { event = JSON.parse(data); } catch (error) { chain = chain.then(() => { throw error; }).catch(fail); return; }
+          if (event?.type === "done") ending = true;
+        }
         chain = chain.then(async () => {
           if (options.signal?.aborted) throw new Error("voice_cancelled");
           if (typeof data !== "string") { player.write(new Uint8Array(data)); return; }
-          const event = JSON.parse(data);
           if (event.type === "segment") {
             if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
             segmentIndex = event.index;
@@ -88,7 +92,7 @@ export async function playAudioStream(options) {
       connection.addEventListener("error", () => fail(dropped()), { once: true });
       connection.addEventListener("close", () => {
         options.signal?.removeEventListener("abort", cancelled);
-        if (!complete) { const error = dropped(); noteFailure(error); reject(error); }
+        if (!complete && !ending) { const error = dropped(); noteFailure(error); reject(error); }
       }, { once: true });
       if (options.signal?.aborted) cancelled();
     });
@@ -140,7 +144,7 @@ export async function startTranscriptionStream(options) {
 export async function createStreamingCapture(stream, options) {
   const port = await (options.port ? options.port(options) : startTranscriptionStream(options));
   if (!port) return null;
-  let context, source, node, failure, flushed;
+  let context, source, node, failure, flushed, captured = 0;
   const release = () => {
     source?.disconnect(); source = null;
     node?.disconnect(); if (node) node.port.onmessage = null; node = null;
@@ -158,7 +162,11 @@ export async function createStreamingCapture(stream, options) {
     node = new AudioWorkletNode(context, "lares-pcm-capture", { numberOfOutputs: 1, outputChannelCount: [1] });
     node.port.onmessage = ({ data }) => {
       if (data.type === "flushed") { flushed?.(); return; }
-      try { port.write(convert(data.samples)); } catch (cause) { failure = cause; port.cancel(); }
+      try {
+        const pcm = convert(data.samples);
+        if (pcm?.length) captured += pcm.length;
+        port.write(pcm);
+      } catch (cause) { failure = cause; port.cancel(); }
     };
     source.connect(node); node.connect(context.destination);
     return {
@@ -168,6 +176,9 @@ export async function createStreamingCapture(stream, options) {
           // No capture messages may follow the ASR commit, even while finalization waits.
           release();
           if (failure) throw failure;
+          // No PCM reached the socket. Committing it makes the Host drop the take
+          // without a transcript, and the composer stays on 转写中.
+          if (!captured) { port.cancel(); return ""; }
           return await port.finish();
         } catch (cause) { port.cancel(); throw cause; }
         finally { release(); }

package/voice/stream-gateway.js

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

package/voice/tts-input.js

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

package/voice/tts-preview.js

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

package/voice/unified-conversation.js

@@ -26,12 +26,12 @@ export function browserRealtimeSocket(ticket) {
  * microphone streams PCM into the socket, the Host transcribes, submits and speaks, and the reply
  * audio plays from the socket instead of a separate synthesis stream.
  */
-export function createUnifiedConversation({ request, socket: openSocket = browserRealtimeSocket, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, preparation, media, player: createPlayer = createPcmStreamPlayer, input: inputPort }) {
+export function createUnifiedConversation({ request, socket: openSocket = browserRealtimeSocket, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, preparation, media, player: createPlayer = createPcmStreamPlayer, input: inputPort, transcribe = async () => { throw new Error("voice_unsupported"); } }) {
   const voiceId = mintRpcId();
   const headset = device === "headset";
   const headers = { "x-lares-voice-id": voiceId, "x-lares-voice-device": headset ? "headset" : "device" };
   let protocol = null, socketOpen = null, disposed = false, timer = null, lastSessionId = null, continuous = false;
-  let turn = null, reply = null, outputSerial = Promise.resolve(), confirmedReadAloud = readAloud;
+  let turn = null, reply = null, outputSerial = Promise.resolve(), confirmedReadAloud = readAloud, hostHeard = false;
   const call = async (path, body, signal) => {
     const res = await request(`/api/lares/voice${path}`, { method: body === undefined ? "GET" : "POST", headers, ...(body === undefined ? {} : { body }), signal });
     if (!res?.ok) throw new Error(res?.body?.error?.code || "voice_failed");
@@ -86,21 +86,35 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
   const transcription = ({ onPartial }) => {
     if (!protocol) throw new Error("voice_disconnected");
     const current = take();
+    hostHeard = false;
     current.onPartial = onPartial;
+    // The promise exists for the whole take. An error while audio is still
+    // streaming has to reject it; waiting until finish() to attach reject left
+    // the composer on 转写中.
+    let settle;
+    const result = new Promise((resolve, reject) => {
+      settle = (error, text) => {
+        if (current.done) return;
+        current.done = true;
+        if (turn === current) turn = null;
+        if (error) reject(error); else resolve(text ?? "");
+      };
+      current.resolve = (text) => settle(null, text);
+      current.reject = (error) => settle(error);
+    });
+    void result.catch(() => {});
     return {
-      write(bytes) { if (turn === current && protocol) protocol.append(encodeBase64(bytes)); },
+      write(bytes) { if (!current.done && protocol) protocol.append(encodeBase64(bytes)); },
       finish() {
-        return new Promise((resolve, reject) => {
-          current.resolve = resolve; current.reject = reject;
-          if (!onTranscript) protocol.setBusyTurn(mode());
-          protocol.commit();
-        });
+        if (current.done) return result;
+        if (!onTranscript) protocol.setBusyTurn(mode());
+        protocol.commit();
+        return result;
       },
-      cancel() { if (turn === current) { turn = null; protocol?.discard(); } },
+      cancel() { if (!current.done) { protocol?.discard(); settle(null, ""); } },
     };
   };
-  const deviceInput = () => createDeviceInput({ media, preparation, onPhase, endpointSilenceMs,
-    transcribe: async () => { throw new Error("voice_unsupported"); },
+  const deviceInput = () => createDeviceInput({ media, preparation, onPhase, endpointSilenceMs, transcribe,
     streamInput: (stream, options) => createStreamingCapture(stream, { ...options, sampleRate: RATE, port: async () => transcription(options) }),
   });
   // Headset: the Host owns the microphone; the socket only opens and closes it.
@@ -128,7 +142,13 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
       case "input_audio_buffer.speech_started": turn?.onSpeech?.(); break;
       case "input_audio_buffer.committed": turn?.onTranscribing?.(); break;
       case "conversation.item.input_audio_transcription.delta": if (turn?.onPartial) { turn.partial = `${turn.partial || ""}${event.delta}`; turn.onPartial(turn.partial); } break;
-      case "conversation.item.input_audio_transcription.completed": { const current = turn; turn = null; current?.resolve?.(event.transcript || ""); break; }
+      case "conversation.item.input_audio_transcription.completed": {
+        // The Host already submitted a non-empty transcript. An empty one did not,
+        // so a later blob fallback has to send the words itself.
+        hostHeard = Boolean(String(event.transcript || "").trim());
+        const current = turn; turn = null; current?.resolve?.(event.transcript || "");
+        break;
+      }
       case "response.created": playback.begin(event); break;
       case "response.output_item.added": if (reply) reply.itemId = event.item?.id || null; break;
       case "response.output_audio_transcript.delta":
@@ -171,7 +191,14 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
       lazy: true,
       create: async () => null,
       // The Host submitted this turn when its audio was committed; only the lifecycle remains to observe.
-      async submit() { await poll(); },
+      async submit({ text } = {}) {
+        // Audio that never reached the socket still has a recording. The Host did not
+        // see that take, so hand the transcript over as a typed turn instead of dropping it.
+        const typed = Boolean(text) && !hostHeard;
+        hostHeard = false;
+        if (typed) protocol?.say(text);
+        await poll();
+      },
       cancel: () => call("/session/cancel", {}),
       running: async () => (await call("/session")).running === true,
     },