@olares/lares-core 0.15.31 → 0.15.32

package/package.json

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

package/voice/speech.js

@@ -134,19 +134,24 @@ export function matchSpeechEvent(event) {
 export function createReplySpeaker() {
   let armed = false;
   let skipKey = null;
+  // The answer that was already on screen when a turn opened is history. A new
+  // turn can deliver its first text in the same snapshot that reports the turn,
+  // and that text must still be read: the old code skipped it by its own key.
+  let lastKey = null;
   return {
     /** @returns {Utterance | null} the utterance to follow now, or null */
     observe({ sessionChanged, wasRunning, running, utterance }) {
       if (sessionChanged) {
         armed = Boolean(running);
-        skipKey = utterance?.key ?? null;
+        skipKey = lastKey = utterance?.key ?? null;
         return null;
       }
       if (!wasRunning && running) {
         armed = true;
-        skipKey = utterance?.key ?? null;
+        skipKey = lastKey;
       }
       const follow = armed && utterance && utterance.key !== skipKey ? utterance : null;
+      if (utterance?.key) lastKey = utterance.key;
       if (!running) armed = false;
       return follow;
     },
@@ -324,6 +329,26 @@ export function createSentencePlayer({ send, play, halt, silence, fail = () => {
     get canPause() { return current?.controls?.canPause === true; },
     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 the current audio without marking the answer read. A voice take
+     * that is cancelled must be able to bring the same answer back; a take
+     * that is submitted consumes it instead.
+     */
+    suspend() {
+      if (!current) return null;
+      const key = current.key;
+      const source = current.source;
+      // `follow` marks a key as read when it starts. A cancelled voice take
+      // must be able to follow the same key again, so undo that mark here.
+      if (key != null) consumed.delete(key);
+      stop();
+      silence(source);
+      return key;
+    },
+    /** Mark an answer read without playing it (a voice take owns it now). */
+    consume(key) {
+      mark(consumed, key);
+    },
     stop() {
       if (!current) return;
       mark(consumed, current.key);

package/voice/stream-client.js

@@ -45,98 +45,180 @@ function clientFacts() {
   };
 }
 
+const RECONNECT_ATTEMPTS = 3;
+const RECONNECT_DELAY_MS = 400;
+
+/** A phone can lose the socket (lock screen, app switch, Wi-Fi/cellular) mid-answer. */
+function reconnectable(error) {
+  const code = error?.message;
+  return code === "voice_disconnected";
+}
+
 export async function playAudioStream(options) {
   const started = Date.now();
-  const connection = await openAudioStream({ ...options, operation: "tts" });
-  if (!connection) throw new Error("voice_stream_failed");
-  const file = createBrowserPlayer();
-  let progressNoted = false, progressBlocked = false;
-  // A phone that suspends the WebView stops the worklet without closing the
-  // socket, so the host waits for frames that will never come. Report that gap
-  // with the page/context state instead of leaving the next test guessing.
-  let lastProgressAt = Date.now(), gapReported = false, gapAt = 0, formatNoted = false;
-  const player = createPcmStreamPlayer({ onProgress: (frames) => {
-    lastProgressAt = Date.now();
-    if (gapReported) { gapReported = false; streamMetric(options, { stage: "playback_gap_end", frames, gapMs: Date.now() - gapAt, ...clientFacts(), context: player.contextState() }); }
-    if (connection.readyState !== 1) {
-      if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", readyState: connection.readyState, frames }); }
-      return;
-    }
-    try { connection.send(JSON.stringify({ type: "progress", frames })); }
-    catch (error) {
-      if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", code: error?.message || "send_failed", frames }); }
-      return;
-    }
-    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, ending = false, firstReceived = false, ready = false, paused = false, segmentIndex = -1;
-  const gapWatch = setInterval(() => {
-    if (!ready || paused || complete || gapReported || Date.now() - lastProgressAt < 4000) return;
-    gapReported = true;
-    gapAt = lastProgressAt;
-    streamMetric(options, { stage: "playback_gap", gapMs: Date.now() - lastProgressAt, frames: player.playedFrames(), ...clientFacts(), context: player.contextState(), sampleRate: player.sampleRate() });
-  }, 1000);
-  gapWatch.unref?.();
-  const noteVisibility = () => {
-    if (ready && !complete) streamMetric(options, { stage: "playback_visibility", frames: player.playedFrames(), paused, ...clientFacts(), context: player.contextState() });
-  };
-  if (typeof document !== "undefined" && document.addEventListener) document.addEventListener("visibilitychange", noteVisibility);
+  const attempts = Math.max(1, Number(options.reconnectAttempts) || RECONNECT_ATTEMPTS);
+  const reconnectDelay = Number.isFinite(options.reconnectDelayMs) ? Math.max(0, options.reconnectDelayMs) : RECONNECT_DELAY_MS;
+  // Frames already rendered before the current socket. A reconnected socket
+  // replays the answer from its first segment; dropping this prefix keeps the
+  // listener where the dropped connection left off.
+  let skipFrames = 0;
+  let lastError = null;
+  let paused = false;
+  const controls = { player: null, connection: null, file: null, ready: false };
   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" })); },
-    resume() { if (!ready || !paused) return; paused = false; player.resume(); void file.resume()?.catch(() => connection.close()); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "resume" })); },
+    get canPause() { return controls.ready; },
+    pause() {
+      if (!controls.ready || paused) return;
+      paused = true; controls.player?.pause(); controls.file?.pause();
+      if (controls.connection?.readyState === 1) controls.connection.send(JSON.stringify({ type: "pause" }));
+    },
+    resume() {
+      if (!controls.ready || !paused) return;
+      paused = false; controls.player?.resume();
+      void controls.file?.resume()?.catch?.(() => controls.connection?.close());
+      if (controls.connection?.readyState === 1) controls.connection.send(JSON.stringify({ type: "resume" }));
+    },
   });
-  try {
-    await new Promise((resolve, reject) => {
-      let failureLogged = false;
-      const noteFailure = (error) => {
-        const code = error?.message || "voice_playback_failed";
-        if (failureLogged || code === "voice_cancelled") return;
-        failureLogged = true;
-        streamMetric(options, { stage: "playback_failed", code, durationMs: Date.now() - started });
-      };
-      const fail = (error) => { noteFailure(error); reject(error); connection.close(); };
-      const cancelled = () => { player.stop(); file.stop(); fail(new Error("voice_cancelled")); };
-      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; }
-          if (event.type === "segment") {
-            if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
-            segmentIndex = event.index;
-          }
-          else if (event.type === "segment.end") options.onSegment?.(event);
-          else if (event.type === "format") {
-            await player.start(event); ready = true; lastProgressAt = Date.now(); if (paused) player.pause();
-            if (!formatNoted) { formatNoted = true; streamMetric(options, { stage: "playback_client", sampleRate: event.sampleRate, context: player.contextState(), ...clientFacts() }); }
+
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    if (attempt > 0) {
+      if (options.signal?.aborted) throw new Error("voice_cancelled");
+      streamMetric(options, { stage: "playback_reconnect", attempt, skipFrames, code: lastError?.message || "voice_disconnected", ...clientFacts() });
+      await new Promise((resolve) => setTimeout(resolve, reconnectDelay));
+      if (options.signal?.aborted) throw new Error("voice_cancelled");
+    }
+    const connection = await openAudioStream({ ...options, operation: "tts" });
+    if (!connection) throw new Error("voice_stream_failed");
+    const file = createBrowserPlayer();
+    let progressNoted = false, progressBlocked = false;
+    let lastProgressAt = Date.now(), gapReported = false, gapAt = 0, formatNoted = false;
+    let chain = Promise.resolve(), complete = false, ending = false, firstReceived = false, ready = false, segmentIndex = -1;
+    // The skipped prefix belongs to this new socket and is acknowledged as it
+    // arrives, so the host keeps sending it without waiting for a playhead
+    // that only starts after the skip.
+    let skipBytes = skipFrames * 2;
+    let skippedFrames = 0;
+    let skipAckAt = 0;
+    const player = createPcmStreamPlayer({
+      onProgress: (frames) => {
+        lastProgressAt = Date.now();
+        if (gapReported) { gapReported = false; streamMetric(options, { stage: "playback_gap_end", frames: skipFrames + frames, gapMs: Date.now() - gapAt, ...clientFacts(), context: player.contextState() }); }
+        ack(skipFrames + frames);
+      },
+      onMetric: (event) => {
+        if (event.stage === "playback_started") options.onStatus?.("playing");
+        streamMetric(options, { ...event, durationMs: Date.now() - started });
+      },
+    });
+    controls.player = player;
+    controls.connection = connection;
+    controls.file = file;
+    controls.ready = false;
+    const ack = (frames) => {
+      if (connection.readyState !== 1) {
+        if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", readyState: connection.readyState, frames }); }
+        return;
+      }
+      try { connection.send(JSON.stringify({ type: "progress", frames })); }
+      catch (error) {
+        if (!progressBlocked) { progressBlocked = true; streamMetric(options, { stage: "playback_progress_blocked", code: error?.message || "send_failed", frames }); }
+        return;
+      }
+      if (!progressNoted) { progressNoted = true; streamMetric(options, { stage: "playback_progress_sent", frames }); }
+    };
+    const writeAudio = (bytes) => {
+      let chunk = bytes;
+      if (skipBytes > 0) {
+        const drop = Math.min(skipBytes, chunk.length);
+        skipBytes -= drop;
+        skippedFrames += drop / 2;
+        if (Date.now() - skipAckAt >= 40) { skipAckAt = Date.now(); ack(skippedFrames); }
+        chunk = chunk.subarray(drop);
+        if (!chunk.length) return;
+      }
+      player.write(chunk);
+    };
+    const gapWatch = setInterval(() => {
+      if (!ready || paused || complete || gapReported || Date.now() - lastProgressAt < 4000) return;
+      gapReported = true;
+      gapAt = lastProgressAt;
+      streamMetric(options, { stage: "playback_gap", gapMs: Date.now() - lastProgressAt, frames: skipFrames + player.playedFrames(), ...clientFacts(), context: player.contextState(), sampleRate: player.sampleRate() });
+    }, 1000);
+    gapWatch.unref?.();
+    const noteVisibility = () => {
+      if (ready && !complete) streamMetric(options, { stage: "playback_visibility", frames: skipFrames + player.playedFrames(), paused, ...clientFacts(), context: player.contextState() });
+    };
+    if (typeof document !== "undefined" && document.addEventListener) document.addEventListener("visibilitychange", noteVisibility);
+    try {
+      await new Promise((resolve, reject) => {
+        let logged = false;
+        const fail = (error) => {
+          if (logged) return;
+          logged = true;
+          reject(error);
+        };
+        const cancelled = () => { player.stop(); file.stop(); fail(new Error("voice_cancelled")); };
+        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;
           }
-          else if (event.type === "file") { ready = true; options.onStatus?.("playing"); await file.play(wavBlob(event.audio)); if (connection.readyState === 1) connection.send(JSON.stringify({ type: "file.done" })); }
-          else if (event.type === "error") throw new Error(event.code || "voice_stream_failed");
-          else if (event.type === "done") { await player.finish(); complete = true; resolve(); }
-        }).catch(fail);
+          chain = chain.then(async () => {
+            if (options.signal?.aborted) throw new Error("voice_cancelled");
+            if (typeof data !== "string") { writeAudio(new Uint8Array(data)); return; }
+            if (event.type === "segment") {
+              if (event.index !== segmentIndex + 1) throw new Error("voice_reply_sequence");
+              segmentIndex = event.index;
+            }
+            else if (event.type === "segment.end") options.onSegment?.(event);
+            else if (event.type === "format") {
+              await player.start(event); ready = controls.ready = true; lastProgressAt = Date.now();
+              if (paused) {
+                player.pause();
+                if (connection.readyState === 1) connection.send(JSON.stringify({ type: "pause" }));
+              }
+              if (!formatNoted) { formatNoted = true; streamMetric(options, { stage: "playback_client", sampleRate: event.sampleRate, context: player.contextState(), ...clientFacts() }); }
+            }
+            else if (event.type === "file") {
+              // A whole-file answer cannot be offset-skipped; a reconnect plays it again.
+              ready = controls.ready = true; options.onStatus?.("playing");
+              await file.play(wavBlob(event.audio));
+              if (connection.readyState === 1) connection.send(JSON.stringify({ type: "file.done" }));
+            }
+            else if (event.type === "error") throw new Error(event.code || "voice_stream_failed");
+            else if (event.type === "done") { await player.finish(); complete = true; resolve(); }
+          }).catch(fail);
+        });
+        const dropped = () => new Error(options.signal?.aborted ? "voice_cancelled" : "voice_disconnected");
+        connection.addEventListener("error", () => fail(dropped()), { once: true });
+        connection.addEventListener("close", () => {
+          options.signal?.removeEventListener("abort", cancelled);
+          if (!complete && !ending) fail(dropped());
+        }, { once: true });
+        if (options.signal?.aborted) cancelled();
       });
-      const dropped = () => new Error(options.signal?.aborted ? "voice_cancelled" : "voice_disconnected");
-      connection.addEventListener("error", () => fail(dropped()), { once: true });
-      connection.addEventListener("close", () => {
-        options.signal?.removeEventListener("abort", cancelled);
-        if (!complete && !ending) { const error = dropped(); noteFailure(error); reject(error); }
-      }, { once: true });
-      if (options.signal?.aborted) cancelled();
-    });
-    return true;
-  } finally {
-    clearInterval(gapWatch);
-    if (typeof document !== "undefined" && document.removeEventListener) document.removeEventListener("visibilitychange", noteVisibility);
-    player.stop(); file.stop(); connection.close();
+      return true;
+    } catch (error) {
+      lastError = error;
+      if (reconnectable(error) && attempt < attempts - 1) {
+        skipFrames += player.playedFrames();
+        continue;
+      }
+      if (error?.message !== "voice_cancelled") {
+        streamMetric(options, { stage: "playback_failed", code: error?.message || "voice_playback_failed", durationMs: Date.now() - started });
+      }
+      throw error;
+    } finally {
+      clearInterval(gapWatch);
+      if (typeof document !== "undefined" && document.removeEventListener) document.removeEventListener("visibilitychange", noteVisibility);
+      if (controls.player === player) { controls.player = null; controls.connection = null; controls.file = null; controls.ready = false; }
+      player.stop(); file.stop(); connection.close();
+    }
   }
+  throw lastError || new Error("voice_disconnected");
 }
 
 /** A single final ASR result; partials never submit a task or replace the draft. */

package/voice/unified-conversation.js

@@ -274,7 +274,9 @@ export function createUnifiedConversation({ request, socket: openSocket = browse
     lastSessionId = state.sessionId;
     if (lastSessionId) controller.bindSession(lastSessionId);
     if (state.error && state.error !== "voice_cancelled") throw new Error(state.error);
-    controller.observeAgent(Boolean(state.running) || Boolean(reply), Boolean(reply?.audio));
+    // A finished reply is not a running agent: keeping it "running" left the
+    // panel on Working forever and blocked the next continuous turn.
+    controller.observeAgent(Boolean(state.running), Boolean(reply?.audio));
   };
   const watch = async () => {
     if (disposed || controller.getSnapshot().connection === "closed") return;