@olares/lares-core 0.15.27 → 0.15.28

package/package.json

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

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/stream-client.js

@@ -144,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;
@@ -162,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 {
@@ -172,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/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,
     },