@olares/lares-core 0.15.17 → 0.15.19

package/voice/controller.js

@@ -1,3 +1,4 @@
+import { createInterruptionGuard } from "./interruption.js";
 import { mintRpcId } from "../larepass/rpc.js";
 
 /** Device, agent and playback ports are injected; UI frameworks own no turn state. */
@@ -44,28 +45,36 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
     old?.abort.abort();
     try { if (old) await input.cancel?.(); } finally { change({ capture: "idle", userSpeaking: false, inputLevel: null }); }
   };
+  const interruption = createInterruptionGuard({ output, now, schedule, unschedule,
+    onState: playback => change({ playback }), onError: error => change({ error }) });
+  const interruptible = () => state.continuous && !manualTurns && input.capabilities?.bargeIn === true && input.capabilities?.echoTested === true && output.canPause === true;
   const stopPlayback = async () => {
+    interruption.cancel();
     const started = now();
-    await output.stop();
+    const pending = output.stop();
     change({ playback: "idle" });
+    await pending;
     report("interrupt", started);
   };
   const listen = async () => {
     if (state.connection !== "open" || state.inputPaused || take || state.capture !== "idle") return;
     if (!manualTurns && state.continuous && (
       (state.agent !== "idle" && !input.capabilities?.listenWhileWorking)
-      || (state.playback !== "idle" && !input.capabilities?.bargeIn)
+      || (state.playback !== "idle" && !interruptible())
     )) return;
     const run = { epoch, abort: new AbortController(), id: mintRpcId(), started: now() };
     take = run;
     change({ capture: "recording", inputReady: false, error: null });
     try {
       const text = String(await input.capture({ signal: run.abort.signal, continuous: state.continuous && !manualTurns, onReady: () => { if (live(run)) change({ inputReady: true }); }, onLevel: (level) => { if (live(run)) change({ inputLevel: Math.max(0, Math.min(1, level)) }); }, onSpeech: () => {
-        if (live(run)) { touch(); change({ userSpeaking: true }); if (input.capabilities?.bargeIn) void stopPlayback(); }
-      }, onTranscribing: () => { if (live(run)) change({ capture: "transcribing", userSpeaking: false }); } }) ?? "").trim();
+        if (live(run)) { touch(); change({ userSpeaking: true }); if (interruptible() && state.playback !== "idle") interruption.suspect(); }
+      }, onTranscribing: () => { if (live(run)) { interruption.speechEnded(); change({ capture: "transcribing", userSpeaking: false }); } } }) ?? "").trim();
       if (!live(run)) return;
       report("recognition", run.started, { turnId: run.id });
-      if (!text) return;
+      const confirming = interruption.pending;
+      interruption.final(text);
+      if (text && !confirming && interruptible() && state.playback !== "idle") await stopPlayback();
+      if (!text) { run.waitingInterruption = confirming; return; }
       touch();
       if (onTranscript) {
         await onTranscript({ text, turnId: run.id, voiceId: state.voiceId, sessionId: state.sessionId, signal: run.abort.signal });
@@ -78,13 +87,14 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
       // Acceptance is not completion; observeAgent receives the durable turn lifecycle.
     } catch (error) {
       if (live(run)) {
+        interruption.fail(error.code || error.message || "voice_failed");
         await controller.disconnect(error.code || error.message || "voice_failed");
       }
     } finally {
       if (take === run) {
         take = null;
         change({ capture: "idle", userSpeaking: false, inputLevel: null });
-        if (!manualTurns && state.continuous && state.connection === "open" && (state.agent === "idle" || input.capabilities?.listenWhileWorking) && state.playback === "idle") {
+        if (!manualTurns && state.continuous && state.connection === "open" && (state.agent === "idle" || input.capabilities?.listenWhileWorking) && (state.playback === "idle" || interruptible())) {
           queueMicrotask(() => { void listen(); });
         }
       }
@@ -119,14 +129,15 @@ export function createVoiceController({ input, agent, output, voiceId = mintRpcI
       if (state.sessionId) await agent.cancel(state.sessionId);
     },
     observeAgent(running, playbackExpected = false) {
-      if (playbackExpected && take && !input.capabilities?.bargeIn) void cancelInput();
+      if (playbackExpected && take && !interruptible()) void cancelInput();
       change({ agent: running ? "running" : "idle", ...(playbackExpected ? { playback: "pending" } : {}) });
       if (!manualTurns && !running && state.continuous) void listen();
     },
     observePlayback(playing) {
+      if (!playing) interruption.outputEnded();
       if (playing !== (state.playback === "playing")) touch();
       change({ playback: playing ? "playing" : "idle" });
-      if (!manualTurns && !playing && state.continuous) void listen();
+      if (!manualTurns && state.continuous && (!playing || interruptible())) void listen();
     },
     async pause() {
       clearTimers(); epoch += 1;

package/voice/conversation.js

@@ -3,21 +3,25 @@ import { createDeviceInput } from "./device-input.js";
 import { createHostInput } from "./host-input.js";
 import { mintRpcId } from "../larepass/rpc.js";
 
-export function createVoiceConversation({ request, transcribe, playback, onReply = () => {}, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, input: inputPort, captureConfig }) {
+export function createVoiceConversation({ request, transcribe, playback, onReply = () => {}, onPhase, mode = () => "queue", device = "device", metric = () => {}, readAloud = true, preset, backend, presentationSession = false, endpointSilenceMs, idleTimeoutMs, recoveryTimeoutMs, onText = () => {}, onTranscript = null, input: inputPort, captureConfig, streamInput, preparation }) {
   const voiceId = mintRpcId();
   const headers = { "x-lares-voice-id": voiceId, "x-lares-voice-device": device };
   let timer = null;
+  let outputAbort = null;
+  let outputRevision = 0, outputSerial = Promise.resolve(), confirmedReadAloud = readAloud;
   let disposed = false;
   let version = -1;
   let lastSessionId = null;
   let spokenKey = null;
   let lastReplyKey = null;
   let mutedKey = null;
+  const mutedTurns = new Set();
+  const mute = (reply, sessionId) => { if (Number.isFinite(reply?.turn)) mutedTurns.add(`${sessionId}:${reply.turn}`); };
   let submitted = false;
   let finalSeen = false;
   let continuous = false;
   let manualCapture = false;
-  let reading = false;
+  let reading = false, lastUtterance = null;
   const call = async (path, body, signal) => {
     const res = await request(`/api/lares/voice${path}`, { method: body === undefined ? "GET" : "POST", headers: { ...headers, "x-lares-voice-speaking": controller.getSnapshot().userSpeaking ? "true" : "false" }, ...(body === undefined ? {} : { body }), signal });
     if (!res?.ok) throw new Error(res?.body?.error?.code || "voice_failed");
@@ -26,11 +30,11 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
   const input = inputPort ?? (device === "headset" ? createHostInput({
     start: (signal) => call("/capture", { config: captureConfig, manual: manualCapture || Boolean(onTranscript) }, signal), status: (signal) => call("/capture", undefined, signal),
     stop: () => call("/capture/stop", {}), cancel: () => call("/capture/cancel", {}),
-  }) : createDeviceInput({ transcribe, onPhase, endpointSilenceMs }));
+  }) : createDeviceInput({ transcribe, streamInput, preparation, onPhase, endpointSilenceMs }));
   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: { async stop() { 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() { mute(lastUtterance, lastSessionId); playback.stop(); await call("/playback/stop", {}); } }, agent: {
     lazy: true,
     create: async () => null,
     async submit({ text, requestId, signal }) {
@@ -53,15 +57,17 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       version = state.version;
       // Reserve playback before releasing the completed Agent turn.
       const reply = state.utterance;
+      lastUtterance = reply;
       if (reply?.text && !reply.silent) onText(reply.text);
       const key = reply ? `${state.sessionId}:${reply.key}` : null;
       lastReplyKey = key;
-      if (["recording", "transcribing"].includes(controller.getSnapshot().capture)) mutedKey = key;
-      const reserve = readAloud && key !== mutedKey && reply?.text && !reply.silent && key !== spokenKey;
+      if (!input.capabilities?.echoTested && ["recording", "transcribing"].includes(controller.getSnapshot().capture)) { mutedKey = key; mute(reply, state.sessionId); }
+      const turnMuted = reply && mutedTurns.has(`${state.sessionId}:${reply.turn}`);
+      const reserve = !turnMuted && readAloud && key !== mutedKey && reply?.text && !reply.silent && key !== spokenKey;
       if (reserve) spokenKey = key;
       controller.observeAgent(Boolean(state.running), Boolean(reserve));
       if (!readAloud || reply?.silent) controller.observePlayback(false);
-      if (readAloud && key !== mutedKey && reply) onReply({ ...reply, key: `${voiceId}:${state.sessionId}:${reply.key}` }, headers);
+      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 (device === "headset" && !state.running && !reading) {
       const audio = await call("/playback/status");
@@ -81,7 +87,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
     if (!disposed) timer = setTimeout(watch, 250);
   };
   const stop = async () => {
-    disposed = true; clearTimeout(timer);
+    disposed = true; outputRevision++; outputAbort?.abort(); clearTimeout(timer);
     await controller.disconnect();
     if (!onTranscript) await call("/session/close", {});
   };
@@ -98,7 +104,7 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       continuous = nextContinuous; submitted = false; finalSeen = false; spokenKey = null;
       disposed = false; version = -1;
       clearTimeout(timer);
-      const initial = onTranscript ? {} : await call("/session", { sessionId, readAloud, presentationSession, ...(preset ? { preset } : {}) });
+      const initial = onTranscript ? {} : await call("/session", { sessionId, readAloud, presentationSession, ...(preset ? { preset } : {}), ...(backend ? { backend } : {}) });
       if (!shouldStart()) { await stop(); return; }
       await controller.start({ sessionId, continuous, manual, running: initial.running, shouldStart });
       controller.setOutputMuted(!readAloud);
@@ -110,19 +116,46 @@ export function createVoiceConversation({ request, transcribe, playback, onReply
       if (onTranscript) { disposed = false; await controller.resume(options); return; }
       const current = await call("/session");
       version = current.version;
+      mute(current.utterance, current.sessionId);
       mutedKey = current.utterance ? `${current.sessionId}:${current.utterance.key}` : null;
       spokenKey = mutedKey;
-      if (!current.active) await call("/session", { sessionId: lastSessionId, readAloud });
+      if (!current.active) await call("/session", { sessionId: lastSessionId, readAloud, presentationSession, ...(preset ? { preset } : {}), ...(backend ? { backend } : {}) });
       else await call("/session/resume", {});
       disposed = false;
       await controller.resume(options);
       void watch();
     },
-    async setReadAloud(value) {
-      readAloud = value === true; mutedKey = lastReplyKey;
-      controller.setOutputMuted(!readAloud);
-      if (!readAloud) await controller.stopPlayback();
-      await call("/session/output", { readAloud });
+    setReadAloud(value) {
+      const next = value === true;
+      if (readAloud === next && confirmedReadAloud === next) return Promise.resolve();
+      const changed = readAloud !== next;
+      readAloud = next;
+      const revision = ++outputRevision;
+      confirmedReadAloud = undefined;
+      if (changed) { mutedKey = lastReplyKey; mute(lastUtterance, lastSessionId); }
+      controller.setOutputMuted(!next);
+      // Stop local audio immediately, while ordering remote changes per VoiceSession.
+      const stopped = Promise.resolve(!next && changed ? controller.stopPlayback() : null).then(() => null, error => error);
+      const result = outputSerial.catch(() => {}).then(async () => {
+        const error = await stopped;
+        if (disposed || revision !== outputRevision) return;
+        if (error) throw error;
+        const abort = outputAbort = new AbortController();
+        try {
+          await call("/session/output", { readAloud: next }, AbortSignal.any([abort.signal, AbortSignal.timeout(10_000)]));
+          if (!disposed && revision === outputRevision) confirmedReadAloud = next;
+        } catch (error) {
+          if (!disposed && revision === outputRevision) {
+            readAloud = false;
+            controller.setOutputMuted(true);
+            playback.stop();
+            controller.observePlayback(false);
+          }
+          throw error;
+        } finally { if (outputAbort === abort) outputAbort = null; }
+      });
+      outputSerial = result;
+      return result;
     },
     records: async () => {
       const res = await request("/api/lares/voice/records", { method: "GET", headers });

package/voice/device-input.js

@@ -10,13 +10,14 @@ export function createEnergyEndpoint(stream, end, onSpeech = () => {}, onLevel =
   const gain = context.createGain();
   gain.gain.value = 0;
   const endpoint = createSpeechEndpoint(options);
-  let heard = false;
+  let heard = false, consecutiveMs = 0;
   const silenceTimer = setTimeout(() => { if (!heard) end(false); }, 10_000);
   processor.onaudioprocess = (event) => {
     const samples = event.inputBuffer.getChannelData(0);
     const rms = frameRms(samples);
     onLevel(rms);
-    if (rms >= 0.004 && !heard) { heard = true; onSpeech(); }
+    consecutiveMs = rms >= 0.004 ? consecutiveMs + samples.length * 1000 / context.sampleRate : 0;
+    if (consecutiveMs >= (options.interruptionMs || 0) && rms >= 0.004 && !heard) { heard = true; onSpeech(); }
     if (endpoint.push(1, rms, samples.length * 1000 / context.sampleRate)) end(true);
   };
   source.connect(processor); processor.connect(gain); gain.connect(context.destination);
@@ -37,7 +38,7 @@ function createInputMeter(stream, onLevel) {
   return { stop() { clearInterval(timer); source.disconnect(); analyser.disconnect(); void context.close(); } };
 }
 
-export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = createEnergyEndpoint, endpointSilenceMs = 500, media } = {}) {
+export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = createEnergyEndpoint, endpointSilenceMs = 500, media, preparation, streamInput, echoTested = false } = {}) {
   let recorder = null;
   let settle = null;
   let timer = null;
@@ -47,30 +48,34 @@ export function createDeviceInput({ transcribe, onPhase = () => {}, endpoint = c
     settle?.(""); settle = null;
   };
   return {
-    capabilities: { duplex: true, bargeIn: false, listenWhileWorking: true, audio: "encoded" },
+    capabilities: { duplex: true, bargeIn: echoTested === true, echoTested: echoTested === true, listenWhileWorking: true, audio: "encoded" },
     capture({ signal, onTranscribing, onReady, onSpeech, onLevel = () => {}, continuous = false } = {}) {
       cancel();
       return new Promise((resolve, reject) => {
+        let ready = false;
         settle = resolve;
         const done = (text) => { clearTimeout(timer); signal?.removeEventListener("abort", cancel); settle = null; resolve(text); };
-        recorder = createVoiceCapture({ media, transcribe, submit: done, onStream: (stream) => {
+        const prepared = preparation; preparation = null;
+        recorder = createVoiceCapture({ media, streamInput, preparation: prepared, transcribe, submit: done, onStream: (stream) => {
           for (const track of stream.getTracks()) track.addEventListener?.("ended", () => { settle = null; cancel(); reject(new Error("voice_device_lost")); }, { once: true });
           if (!continuous) return createInputMeter(stream, onLevel);
           return endpoint(stream, (heard = true) => { if (heard) recorder?.stop(); else {
             if (continuous) { cancel(); done(""); }
             else { settle = null; cancel(); reject(new Error("voice_no_input")); }
-          } }, onSpeech, onLevel, { silenceMs: endpointSilenceMs });
+          } }, onSpeech, onLevel, { silenceMs: endpointSilenceMs, interruptionMs: echoTested ? 500 : 0 });
         }, onPhase(phase, extra) {
           onPhase(phase, extra);
-          if (phase === "recording") onReady?.();
+          if (phase === "recording" && !ready) {
+            ready = true; onReady?.();
+            timer = setTimeout(() => { if (continuous) recorder?.stop(); else { settle = null; cancel(); reject(new Error("voice_capture_limit")); } }, 60_000);
+          }
           if (phase === "transcribing") onTranscribing?.();
           if (phase === "error") {
-            if (continuous && ["voice_no_input", "voice_too_short"].includes(extra.error)) { done(""); return; }
+            if (continuous && (extra.recognizedEmpty || !echoTested && ["voice_no_input", "voice_too_short"].includes(extra.error))) { done(""); return; }
             clearTimeout(timer); signal?.removeEventListener("abort", cancel); settle = null; reject(new Error(extra.error)); }
         } });
         signal?.addEventListener("abort", cancel, { once: true });
         if (signal?.aborted) { cancel(); return; }
-        timer = setTimeout(() => { if (continuous) recorder?.stop(); else { settle = null; cancel(); reject(new Error("voice_capture_limit")); } }, 60_000);
         void recorder.start();
       });
     },

package/voice/dialogue.js

@@ -8,7 +8,7 @@ export async function voiceChat({ messages, model = "default-chat", owner, signa
   const response = await request(`${routerGatewayUrl(env)}/chat/completions`, {
     method: "POST", signal: AbortSignal.any([AbortSignal.timeout(45_000), ...(signal ? [signal] : [])]),
     headers: { "content-type": "application/json", ...routerAuthHeaders(env.LARES_ROUTER_API_KEY, env.OLARES_APP_ID, owner) },
-    body: JSON.stringify({ model, messages, ...(tools ? { tools, tool_choice: "auto" } : {}), stream: Boolean(onDelta), max_tokens: maxTokens }),
+    body: JSON.stringify({ model, messages, ...(tools ? { tools, tool_choice: "auto" } : {}), stream: Boolean(onDelta), ...(maxTokens === null ? {} : { max_tokens: maxTokens }) }),
   });
   if (!response.ok) throw Object.assign(new Error("voice_chat_failed"), { code: "voice_chat_failed", status: 502 });
   if (onDelta) {
@@ -90,12 +90,13 @@ export function createVoiceDialogue({ config, owner, context = [], summary = "",
   };
 }
 
-export async function cleanDictation(text, { config, owner, signal, chat = voiceChat, preset = config.dictationPreset || "clean" }) {
+export async function cleanDictation(text, { config, owner, signal, chat = voiceChat, preset = config.dictationPreset || "raw" }) {
   if (!DICTATION_PRESETS.includes(preset)) throw Object.assign(new Error("voice_config_invalid"), { status: 400 });
   if (preset === "raw") return text;
   const profile = (config.dictationProfiles || defaultDictationProfiles())[preset];
   if (!profile?.model) throw new Error("voice_dictation_model_missing");
-  const result = await chat({ owner, model: profile.model, signal, maxTokens: 8192, messages: [
+  // Router groups may select backends with different output limits.
+  const result = await chat({ owner, model: profile.model, signal, maxTokens: null, messages: [
     { role: "system", content: `${DICTATION_BOUNDARY}\n${profile.instructions}` },
     { role: "user", content: text },
   ] });

package/voice/host-service.js

@@ -2,6 +2,8 @@ import { createVoiceAgentSession } from "./agent-session.js";
 import { createVoiceRecords } from "./records.js";
 import { createVoiceDialogue, cleanDictation } from "./dialogue.js";
 import { readConfig, validateConfigPatch } from "./config.js";
+import { listModels } from "../router/stt.js";
+import { validatedRealtimeModels } from "./realtime.js";
 import { VOICE_PRESETS } from "./options.js";
 
 const failure = (code, status) => Object.assign(new Error(code), { code, status });
@@ -46,9 +48,12 @@ export function createVoiceHostService(api, { env = process.env, metric = () =>
       const selected = config();
       const preset = body.preset || selected.preset;
       if (!VOICE_PRESETS.includes(preset)) throw failure("voice_preset_invalid", 400);
+      const backend = body.backend === undefined ? selected.backend : validateConfigPatch({ backend: body.backend }).backend;
+      if (body.backend === "realtime" && !validatedRealtimeModels(await listModels(), env).includes(selected.realtimeModel)) throw failure("voice_realtime_unavailable", 409);
+      if (scope.epoch !== epoch) throw failure("voice_session_closed", 409);
       scopes.add(scope);
       scope.voiceAbort = new AbortController();
-      scope.voiceConfig = { ...selected, preset };
+      scope.voiceConfig = { ...selected, preset, backend };
       const history = records.read(ownerOf(scope), boundSessionId || `voice:${scope.contextId || scope.id}`);
       scope.recoveryContext = history.summary || null;
       const restoredRequests = [...new Set(history.records.map((row) => row.taskId).filter(Boolean))].map((requestId) => ({ requestId }));
@@ -64,7 +69,7 @@ export function createVoiceHostService(api, { env = process.env, metric = () =>
       scope.active = true; scope.readAloud = body.readAloud === true;
       scope.voiceState = { version: 0, running: false, utterance: null, error: null };
       scope.voiceRequests = new Map(); scope.deliveredTasks = new Set(restoredRequests.map((item) => item.requestId));
-      scope.dialogue = createVoiceDialogue({ config: scope.voiceConfig, owner: scope.owner, context: history.summary?.recent || [], summary: history.summary?.text || "", chat,
+      scope.dialogue = preset === "direct" ? null : createVoiceDialogue({ config: scope.voiceConfig, owner: scope.owner, context: history.summary?.recent || [], summary: history.summary?.text || "", chat,
         submit: async (text, requestId, operation) => {
           if (operation === "status") return scope.session.snapshot();
           const id = `${requestId}:delegate`;

package/voice/interruption.js

@@ -0,0 +1,44 @@
+/** A suspected acoustic interruption preserves audio until ASR actually settles. */
+export function createInterruptionGuard({ output, onState = () => {}, onError = () => {}, now = Date.now, schedule = setTimeout, unschedule = clearTimeout, silenceMs = 2000, limitMs = 10000 }) {
+  let candidate = null;
+  const clear = () => {
+    if (!candidate) return;
+    unschedule(candidate.limit); unschedule(candidate.resume);
+    candidate = null;
+  };
+  const valid = run => candidate === run && run.key === output.key?.();
+  const stop = code => {
+    clear(); void Promise.resolve(output.stop()).catch(() => {});
+    onState("idle"); if (code) onError(code);
+  };
+  return {
+    get pending() { return Boolean(candidate); },
+    suspect() {
+      if (candidate && !valid(candidate)) clear();
+      if (candidate) { unschedule(candidate.resume); candidate.empty = false; candidate.endedAt = null; return true; }
+      if (typeof output.key?.() !== "string" || output.canPause !== true || output.pause() === false) return false;
+      const run = candidate = { key: output.key?.(), limit: null, resume: null, endedAt: null, empty: false };
+      run.limit = schedule(() => { if (valid(run)) stop("voice_interruption_timeout"); else if (candidate === run) clear(); }, limitMs);
+      onState("confirming"); return true;
+    },
+    outputEnded() { clear(); },
+    speechEnded() { if (candidate) candidate.endedAt = now(); },
+    final(text) {
+      const run = candidate;
+      if (!run) return;
+      if (!valid(run)) { if (candidate === run) clear(); return; }
+      if (text.trim()) { stop(); return; }
+      run.empty = true;
+      if (run.endedAt == null) run.endedAt = now();
+      unschedule(run.resume);
+      run.resume = schedule(() => {
+        if (!valid(run) || !run.empty) { if (candidate === run) clear(); return; }
+        clear();
+        try { Promise.resolve(output.resume()).catch(() => { if (output.key?.() === run.key) stop("voice_playback_failed"); }); onState("playing"); }
+        catch { stop("voice_playback_failed"); }
+      }, Math.max(0, silenceMs - (now() - run.endedAt)));
+    },
+    fail(code) { if (candidate) stop(code); },
+    cancel() { clear(); },
+  };
+}

package/voice/lares-policy.js

@@ -0,0 +1,12 @@
+import { voiceAvailability } from "./presentation.js";
+
+/** Product entry policy is scoped to this connection, never written to API defaults. */
+export function laresVoiceConfig(config, mode = "continuous") {
+  return { ...structuredClone(config), preset: mode === "single" ? "dictation" : "direct", backend: "pipeline" };
+}
+
+export function laresVoiceAvailability(settings, agentAvailable = false) {
+  const available = voiceAvailability(settings ? { ...settings, config: laresVoiceConfig(settings.config || {}) } : null);
+  return { ...available, conversation: available.conversation && agentAvailable === true,
+    reason: available.conversation && agentAvailable !== true ? "agent" : available.reason };
+}

package/voice/options.js

@@ -2,12 +2,13 @@ import { defaultDictationProfiles } from "./dictation.js";
 
 export const VOICE_DEFAULTS = {
   preset: "assistant",
-  dictationPreset: "clean",
+  dictationPreset: "raw",
   dictationProfiles: defaultDictationProfiles(),
   dictationShortcuts: { default: "", raw: "", clean: "", outline: "", summary: "" },
   chatModel: "default-chat",
   instructions: "",
   voice: "",
+  ttsVoiceByModel: {},
   mode: "single",
   mobileMode: "continuous",
   endpointSilenceMs: 500,

package/voice/panel.js

@@ -1,17 +1,21 @@
+import { setVoiceActivity } from "./activity.js";
 import { DICTATION_PRESETS } from "./dictation.js";
 
 /** The panel owns drafts and turn policy; adapters only supply settings, audio and insertion ports. */
-export function createVoicePanel({ create, complete, loadConfig = async () => ({}), process = async ({ text }) => text, onSession = () => {}, manualTurns = true, inlineDictation = false }) {
-  let state = { visible: false, inputActive: false, previewVisible: false, mode: "single", sessionId: null, raw: "", draft: "", edited: false, preset: "clean", stage: "idle", snapshot: null, busy: false, error: null, device: "", levels: [], startedAt: null, elapsedMs: 0, holding: false, cancelArmed: false };
+export function createVoicePanel({ create, complete, loadConfig = async () => ({}), process = async ({ text }) => text, onSession = () => {}, manualTurns = true, inlineDictation = false, prepareInput = () => null }) {
+  let state = { visible: false, inputActive: false, previewVisible: false, mode: "single", sessionId: null, raw: "", draft: "", edited: false, preset: "raw", stage: "idle", snapshot: null, busy: false, error: null, readAloudError: null, device: "", levels: [], startedAt: null, elapsedMs: 0, holding: false, cancelArmed: false };
   let call = null, config = null, generation = 0, intent = 0, processing = null;
+  let inputPreparation = null;
+  let readAloudPreference, appliedReadAloud, readAloudPending = null, readAloudReady = false, outputRevision = 0;
+  const cancelPreparation = () => { inputPreparation?.cancel(); inputPreparation = null; };
   let unsubscribe = () => {};
   let serial = Promise.resolve();
   const drafts = new Map(), listeners = new Set();
-  const emit = (patch) => { state = { ...state, ...patch }; state.previewVisible = !inlineDictation && state.visible && state.mode === "single" && (state.stage === "preview" || state.stage === "processing" && state.previewVisible); state.inputActive = state.visible && !state.previewVisible; for (const listener of listeners) listener(); };
+  const emit = (patch) => { state = { ...state, ...patch }; state.previewVisible = !inlineDictation && state.visible && state.mode === "single" && (state.stage === "preview" || state.stage === "processing" && state.previewVisible); state.inputActive = state.visible && !state.previewVisible; setVoiceActivity(listeners, state.visible && (state.busy || state.snapshot?.capture === "recording" || state.snapshot?.capture === "transcribing" || state.snapshot?.connection === "open")); for (const listener of listeners) listener(); };
   const save = () => state.mode === "single" && drafts.set(state.sessionId, { raw: state.raw, draft: state.draft, edited: state.edited, preset: state.preset, config });
   const cancelProcessing = () => { processing?.abort(); processing = null; };
   const enqueue = (operation) => {
-    const result = serial.catch(() => {}).then(async () => { emit({ busy: true, error: null }); try { return await operation(); } catch (error) { emit({ error: error.code || error.message, holding: false, cancelArmed: false }); throw error; } finally { emit({ busy: false }); } });
+    const result = serial.catch(() => {}).then(async () => { emit({ busy: true, error: null }); try { return await operation(); } catch (error) { cancelPreparation(); emit({ error: error.code || error.message, holding: false, cancelArmed: false }); throw error; } finally { emit({ busy: false }); } });
     serial = result; return result;
   };
   const finishCapture = async () => {
@@ -26,9 +30,9 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     });
   };
   const end = async () => {
-    generation++; unsubscribe(); unsubscribe = () => {};
+    generation++; outputRevision++; readAloudReady = false; appliedReadAloud = undefined; readAloudPending = null; unsubscribe(); unsubscribe = () => {};
     const previous = call; call = null;
-    try { await previous?.stop(); } finally { emit({ snapshot: null, startedAt: null, elapsedMs: 0, levels: [] }); }
+    try { await previous?.stop(); } finally { emit({ snapshot: null, readAloudError: null, startedAt: null, elapsedMs: 0, levels: [] }); }
   };
   const renderDraft = () => { emit({ stage: state.raw ? "preview" : "idle" }); save(); };
   const transform = async (preset) => {
@@ -56,24 +60,30 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     if (call?.controller.getSnapshot().connection === "open") return;
     await end(); config = state.mode === "single" && config ? config : structuredClone(await loadConfig());
     if (token !== intent || !state.visible) return;
+    if (state.mode === "continuous" && typeof readAloudPreference === "boolean") config = { ...config, speak: readAloudPreference };
+    const initialReadAloud = state.mode === "continuous" && config.speak === true;
     const target = state.sessionId, epoch = ++generation;
-    const conversation = await create({ mode: state.mode, sessionId: target, config,
+    const conversation = await create({ mode: state.mode, sessionId: target, config, preparation: inputPreparation,
       onTranscript({ text }) {
         if (epoch !== generation) return;
         const raw = [state.raw, text].filter(Boolean).join(" "); emit({ raw, draft: raw, edited: false }); save();
       }, onDevice(device) { if (epoch === generation) emit({ device }); },
     });
     if (token !== intent || !state.visible) { await conversation.stop(); return; }
-    call = conversation;
+    call = conversation; appliedReadAloud = initialReadAloud;
     unsubscribe = call.controller.subscribe(() => {
       if (epoch !== generation) return;
       const snapshot = call.controller.getSnapshot();
       if (!state.sessionId && snapshot.sessionId) { emit({ sessionId: snapshot.sessionId }); onSession(snapshot.sessionId); }
       emit({ snapshot, ...(snapshot.inputLevel == null ? {} : { levels: [...state.levels.slice(-19), snapshot.inputLevel] }),
-        ...(snapshot.capture === "recording" && state.snapshot?.capture !== "recording" ? { startedAt: Date.now(), elapsedMs: 0 } : snapshot.capture !== "recording" && state.startedAt ? { startedAt: null, elapsedMs: Date.now() - state.startedAt } : {}) });
+        ...(snapshot.capture === "recording" && snapshot.inputReady && !state.startedAt ? { startedAt: Date.now(), elapsedMs: 0 } : snapshot.capture !== "recording" && state.startedAt ? { startedAt: null, elapsedMs: Date.now() - state.startedAt } : {}) });
     });
     await call.start({ sessionId: target, continuous: state.mode === "continuous", manual: state.mode === "continuous" && manualTurns, shouldStart: () => token === intent && state.visible });
     if (token !== intent || !state.visible) await call.controller.cancelRecording();
+    else {
+      readAloudReady = true;
+      if (state.mode === "continuous" && typeof readAloudPreference === "boolean") await panel.setReadAloud(readAloudPreference);
+    }
   };
   const pause = async () => {
     try { if (state.mode === "single") { await finishCapture(); renderDraft(); } else await call?.controller.cancelRecording(); }
@@ -89,27 +99,55 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     getSnapshot: () => state,
     subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
     get conversation() { return call; },
-    open({ mode = state.mode, sessionId = state.sessionId, preset } = {}) {
+    setReadAloud(value) {
+      const next = readAloudPreference = value === true;
+      if (config) config = { ...config, speak: next };
+      const target = call, epoch = generation;
+      if (!readAloudReady || !target?.setReadAloud || state.mode !== "continuous") return Promise.resolve(true);
+      if (readAloudPending?.target === target && readAloudPending.value === next) return readAloudPending.promise;
+      if (!readAloudPending && appliedReadAloud === next && !state.readAloudError) return Promise.resolve(true);
+      const revision = ++outputRevision;
+      const current = () => target === call && epoch === generation && revision === outputRevision;
+      const pending = { target, value: next, promise: null };
+      pending.promise = Promise.resolve().then(() => {
+        if (target !== call || epoch !== generation) return;
+        return target.setReadAloud(next);
+      }).then(() => {
+        if (current()) { appliedReadAloud = next; emit({ readAloudError: null }); }
+        return true;
+      }, error => {
+        if (current()) emit({ readAloudError: error.code || error.message || "voice_failed" });
+        return false;
+      }).finally(() => { if (readAloudPending === pending) readAloudPending = null; });
+      readAloudPending = pending;
+      return pending.promise;
+    },
+    retryReadAloud() { return panel.setReadAloud(readAloudPreference); },
+    open({ mode = state.mode, sessionId = state.sessionId, preset, configSnapshot } = {}) {
+      if (state.busy) return Promise.resolve();
+      cancelPreparation();
+      const snapshot = configSnapshot ? structuredClone(configSnapshot) : null;
+      if (mode === "single" && snapshot && !(sessionId === state.sessionId ? state.raw : drafts.get(sessionId)?.raw)) inputPreparation = prepareInput(snapshot);
       const token = ++intent; emit({ visible: true });
       return enqueue(async () => {
         if (sessionId !== state.sessionId || mode !== state.mode) {
-          try { await pause(); } finally { await end(); save(); const held = drafts.get(sessionId); config = held?.config || null; emit({ sessionId, mode, raw: mode === "single" ? held?.raw || "" : "", draft: mode === "single" ? held?.draft || "" : "", edited: mode === "single" && (held?.edited || false), preset: held?.preset || "clean", stage: mode === "single" && held?.raw ? "preview" : "idle" }); }
+          try { await pause(); } finally { await end(); save(); const held = drafts.get(sessionId); config = held?.config || null; emit({ sessionId, mode, raw: mode === "single" ? held?.raw || "" : "", draft: mode === "single" ? held?.draft || "" : "", edited: mode === "single" && (held?.edited || false), preset: held?.preset || "raw", stage: mode === "single" && held?.raw ? "preview" : "idle" }); }
         }
         if (mode === "single" && !state.raw && token === intent && state.visible) {
-          config = structuredClone(await loadConfig());
-          emit({ preset: preset || config.dictationPreset || "clean" });
+          config = snapshot || structuredClone(await loadConfig());
+          emit({ preset: preset || config.dictationPreset || "raw" });
           await prepare(token); if (token === intent && state.visible) emit({ stage: "recording" });
         }
       });
     },
     bind(sessionId) {
       if (sessionId === state.sessionId) return Promise.resolve();
-      intent++; cancelProcessing(); emit({ visible: false, holding: false, cancelArmed: false });
+      intent++; cancelPreparation(); cancelProcessing(); emit({ visible: false, holding: false, cancelArmed: false });
       if (state.mode === "continuous") void call?.controller.cancelRecording();
-      return enqueue(async () => { try { await pause(); } finally { await end(); save(); const held = drafts.get(sessionId); config = held?.config || null; emit({ sessionId, raw: held?.raw || "", draft: held?.draft || "", edited: held?.edited || false, preset: held?.preset || "clean", stage: held?.raw ? "preview" : "idle" }); } });
+      return enqueue(async () => { try { await pause(); } finally { await end(); save(); const held = drafts.get(sessionId); config = held?.config || null; emit({ sessionId, raw: held?.raw || "", draft: held?.draft || "", edited: held?.edited || false, preset: held?.preset || "raw", stage: held?.raw ? "preview" : "idle" }); } });
     },
-    close() { intent++; cancelProcessing(); emit({ visible: false, holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
-    pause() { intent++; cancelProcessing(); emit({ holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
+    close() { intent++; cancelPreparation(); cancelProcessing(); emit({ visible: false, holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
+    pause() { intent++; cancelPreparation(); cancelProcessing(); emit({ holding: false, cancelArmed: false }); if (state.mode === "continuous") void call?.controller.cancelRecording(); return enqueue(pause); },
     start() { const token = ++intent; return enqueue(() => prepare(token)); },
     finish() {
       if (state.busy) return Promise.resolve();
@@ -124,6 +162,9 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
     edit(text) { cancelProcessing(); emit({ draft: text, edited: true, stage: "preview" }); save(); },
     selectPreset(preset, replaceEdited = false) {
       if (state.edited && !replaceEdited) return Promise.resolve(false);
+      if (preset === "raw" && state.raw && state.stage === "processing") {
+        intent++; cancelProcessing();
+      }
       return enqueue(async () => { await transform(preset); return true; });
     },
     holdStart() {
@@ -143,9 +184,9 @@ export function createVoicePanel({ create, complete, loadConfig = async () => ({
       return Promise.resolve(cancel || !call.controller.getSnapshot().inputReady ? call.controller.cancelRecording() : call.controller.stopRecording());
     },
     complete() { return enqueue(insertDraft); },
-    discard() { intent++; cancelProcessing(); void call?.controller.cancelRecording().catch(() => {}); return enqueue(async () => { await end(); drafts.delete(state.sessionId); config = null; emit({ raw: "", draft: "", edited: false, stage: "idle", visible: false }); }); },
-    end() { intent++; emit({ holding: false, cancelArmed: false }); return enqueue(async () => { await end(); emit({ visible: false }); }); },
-    dispose() { intent++; cancelProcessing(); return enqueue(async () => { try { await end(); } finally { listeners.clear(); drafts.clear(); } }); },
+    discard() { intent++; cancelPreparation(); cancelProcessing(); void call?.controller.cancelRecording().catch(() => {}); return enqueue(async () => { await end(); drafts.delete(state.sessionId); config = null; emit({ raw: "", draft: "", edited: false, stage: "idle", visible: false }); }); },
+    end() { intent++; cancelPreparation(); emit({ visible: false, holding: false, cancelArmed: false }); return enqueue(async () => { await end(); emit({ visible: false }); }); },
+    dispose() { intent++; cancelPreparation(); cancelProcessing(); return enqueue(async () => { try { await end(); } finally { setVoiceActivity(listeners, false); listeners.clear(); drafts.clear(); } }); },
   };
   return panel;
 }