@olares/lares-core 0.15.17 → 0.15.18

package/router/catalog.js

@@ -1,6 +1,4 @@
 const SAFE_MODEL_ID = /^[^\u0000-\u001f\u007f]{1,512}$/;
-/** pi-ai's thinking vocabulary; a Router level outside it has no wire spelling to declare. */
-const THINKING_LEVELS = new Set(["off", "minimal", "low", "medium", "high", "xhigh", "max"]);
 
 /**
  * The capability flags one catalog row declares, named without Router's
@@ -23,20 +21,12 @@ function capabilities(item) {
   return flags;
 }
 
-/**
- * The effort levels Router advertises for one model, keyed by pi-ai level with
- * Router's own spelling as the wire value. A dict offering nothing beyond `off`
- * is no capability at all, and pi-ai rejects it.
- */
+/** Keep Router identifiers and their declared order independent of adapter vocabulary. */
 function reasoningEfforts(item, flags) {
   if (!flags.has("reasoning_effort")) return null;
   const options = Array.isArray(item.reasoning_effort?.options) ? item.reasoning_effort.options : [];
-  const efforts = {};
-  for (const option of options) {
-    const level = String(option ?? "").trim().toLowerCase();
-    if (THINKING_LEVELS.has(level)) efforts[level] = level;
-  }
-  return Object.keys(efforts).some((level) => level !== "off") ? efforts : null;
+  const entries = options.filter((value) => typeof value === "string" && value.length > 0);
+  return entries.length ? Object.fromEntries(entries.map((value) => [value, value])) : null;
 }
 
 /**
@@ -80,7 +70,10 @@ export function routerCatalogRows(payload) {
       supportsVision: flags.has("vision"),
       supportsStt: flags.has("stt") || flags.has("stt_stream"),
       supportsTts: flags.has("tts"),
+      supportsSttStream: flags.has("stt_stream"),
       reasoningEfforts: reasoningEfforts(item, flags),
+      ...(item.reasoning_effort?.default && (item.reasoning_effort.options ?? []).includes(item.reasoning_effort.default)
+        ? { reasoningDefault: item.reasoning_effort.default } : {}),
       contextWindow,
       maxTokens: outputTokenBudget(tokenCount(item.max_output_tokens), contextWindow),
     });

package/router/default-selection.d.ts

@@ -0,0 +1,3 @@
+export interface ModelSelection { provider: string; model: string; reasoningEffort?: string }
+export function resolveDefaultSelection<T extends ModelSelection>(current: T, models: { id: string }[]): T | ModelSelection;
+export function ensureDefaultSelection(service: { currentSelection(): ModelSelection; saveSelection(next: ModelSelection, options: { expected: ModelSelection }): Promise<void> } | undefined, models: { id: string }[]): Promise<void>;

package/router/default-selection.js

@@ -0,0 +1,22 @@
+import { ROUTER_PROVIDER_ID, isPlaceholderModelId } from "./models.js";
+
+export function resolveDefaultSelection(current, models) {
+  if (!models.length || current?.provider === ROUTER_PROVIDER_ID && models.some(model => model.id === current.model && !isPlaceholderModelId(model.id))) return current;
+  const first = models.find(model => !isPlaceholderModelId(model.id));
+  return first ? { provider: ROUTER_PROVIDER_ID, model: first.id } : current;
+}
+
+const pending = new WeakMap();
+export async function ensureDefaultSelection(service, models) {
+  if (!service) return;
+  if (pending.has(service)) {
+    await pending.get(service);
+    return ensureDefaultSelection(service, models);
+  }
+  const current = service.currentSelection();
+  const next = resolveDefaultSelection(current, models);
+  if (next === current) return;
+  const task = service.saveSelection(next, { expected: current });
+  pending.set(service, task);
+  try { await task; } finally { if (pending.get(service) === task) pending.delete(service); }
+}

package/router/model-authorization.js

@@ -0,0 +1,53 @@
+import { catalogCache } from "./catalog-cache.js";
+import { catalogCoordinator } from "./catalog-coordinator.js";
+import { isChatModel, isPlaceholderModelId, ROUTER_PROVIDER_ID } from "./models.js";
+
+export async function authorizedCatalog(cache = catalogCache) {
+  try {
+    return { rows: (await cache.get()).rows.filter(isChatModel), failures: [] };
+  } catch (error) {
+    return { rows: cache.snapshot().rows.filter(isChatModel), failures: [{ id: ROUTER_PROVIDER_ID, name: "Olares Router", message: error instanceof Error ? error.message : String(error) }] };
+  }
+}
+
+export async function authorizedChatModel(selection, cache) {
+  if (isPlaceholderModelId(selection.model)) return false;
+  if (selection.provider !== ROUTER_PROVIDER_ID) return false;
+  const { rows } = cache ? await cache.get() : catalogCoordinator.committed ?? { rows: [] };
+  return rows.some((row) => row.id === selection.model && isChatModel(row));
+}
+
+export function routerReasoningSnapshot() { return catalogCoordinator.committed?.rows ?? []; }
+
+export function routerReasoningInfo(provider, id, rows = routerReasoningSnapshot()) {
+  if (provider !== ROUTER_PROVIDER_ID) return {};
+  const row = rows.find((row) => row.id === id);
+  if (!row?.reasoningEfforts) return { reasoning: undefined };
+  const efforts = Object.keys(row.reasoningEfforts).map((id) => ({ id, name: id }));
+  return { reasoning: { efforts, ...(row.reasoningDefault ? { defaultEffort: row.reasoningDefault } : {}) } };
+}
+
+export function routerReasoningPayload(payload, id, effort, rows = routerReasoningSnapshot()) {
+  const next = { ...payload };
+  if (effort === undefined) {
+    delete next.reasoning_effort;
+    return next;
+  }
+  const wire = rows.find((row) => row.id === id)?.reasoningEfforts?.[effort];
+  if (wire !== effort) throw new Error(`Unsupported reasoning effort: ${effort}`);
+  next.reasoning_effort = wire;
+  return next;
+}
+
+export function normalizeRouterSelection(selection, rows = routerReasoningSnapshot()) {
+  if (selection?.provider !== ROUTER_PROVIDER_ID || selection.reasoningEffort !== "off") return selection;
+  const efforts = rows.find((row) => row.id === selection.model)?.reasoningEfforts;
+  if (!efforts || Object.hasOwn(efforts, "off") || !Object.hasOwn(efforts, "none")) return selection;
+  return { ...selection, reasoningEffort: "none" };
+}
+
+export async function restoreRouterSelection(selection, save, rows = routerReasoningSnapshot()) {
+  const next = normalizeRouterSelection(selection, rows);
+  if (next !== selection) await save(next);
+  return next;
+}

package/router/model-state.js

@@ -0,0 +1,35 @@
+export function modelState({ status, groups = [], models, current, failures = [], error } = {}) {
+  const entries = models ?? groups.flatMap((group) => group.models.map((model) => ({ ...model, provider: group.id })));
+  const selected = current?.model?.trim();
+  const placeholder = !selected || selected === "default";
+  const found = !placeholder && entries.find((row) => row.provider === current.provider && row.id === selected);
+  const effort = current?.reasoningEffort;
+  const effortUnavailable = found && effort !== undefined
+    && !(found.reasoning?.efforts?.some((row) => row.id === effort)
+      || Object.hasOwn(found.reasoningEfforts ?? {}, effort));
+  const state = error || failures.length ? "error"
+    : status === "loading" || status === "idle" ? "loading"
+      : selected && !found ? "unavailable"
+        : !entries.length ? "empty"
+          : placeholder ? "unselected" : effortUnavailable ? "effort-unavailable" : "ready";
+  return { state, valid: Boolean(found) && state !== "loading" && state !== "error" && !effortUnavailable };
+}
+
+export function modelStateLabel(snapshot, locale = "en") {
+  const { state } = modelState(snapshot);
+  const zh = locale.startsWith("zh");
+  const id = snapshot.current?.model;
+  const name = id?.split("/").at(-1);
+  if (state === "loading") return zh ? "正在加载模型" : "Loading models";
+  if (state === "error") return zh ? `${name || "模型目录"} · 加载失败，请刷新` : `${name || "Models"} · refresh failed`;
+  if (state === "unavailable") return zh ? `${name} · 不可用` : `${name} · unavailable`;
+  if (state === "effort-unavailable") return zh ? `${name} · 思考档位 ${snapshot.current.reasoningEffort} 不可用` : `${name} · effort ${snapshot.current.reasoningEffort} unavailable`;
+  if (state === "empty") return zh ? "暂无可用聊天模型" : "No chat models available";
+  if (state === "unselected") return zh ? "请选择模型" : "Select a model";
+  return name;
+}
+
+export function requireComposerModel(snapshot, locale) {
+  if (modelState(snapshot).valid) return;
+  throw new Error(modelStateLabel(snapshot, locale));
+}

package/router/models.js

@@ -35,13 +35,9 @@ export function modelsFromRouterCatalog(payload) {
   return routerCatalogRows(payload);
 }
 
-function isMtpModelId(id) {
-  return /\bmtp\b/i.test(id);
-}
-
 export function pickChatModelId(catalog) {
   const chat = catalog.filter(isChatModel);
-  return chat.find((model) => isMtpModelId(model.id))?.id ?? chat[0]?.id ?? null;
+  return chat[0]?.id ?? null;
 }
 
 export function isPlaceholderModelId(id) {
@@ -64,7 +60,7 @@ export function chatModelsFromRouterCatalog(payload) {
 }
 
 export function pickDefaultModel(models) {
-  return models.find((model) => isMtpModelId(model.id)) ?? models[0] ?? null;
+  return models[0] ?? null;
 }
 
 export function catalogFailure(code, status, message) {

package/router/session-model.js

@@ -35,30 +35,20 @@ export function isSameSessionModel(current, group, model) {
 }
 
 export function currentEffortId(current, reasoning) {
-  return current?.reasoningEffort ?? reasoning?.defaultEffort;
+  return current?.reasoningEffort;
 }
 
-const EFFORT_ORDER = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
-
 /** Router catalog dict `{ low: "low" }` → the effort menu shape the switcher already uses. */
 export function reasoningFromEfforts(raw) {
   if (!raw || typeof raw !== "object") return undefined;
   if (Array.isArray(raw.efforts)) {
     return raw.efforts.length ? raw : undefined;
   }
-  const efforts = [];
-  for (const id of EFFORT_ORDER) {
-    if (raw[id] != null) efforts.push({ id, name: id });
-  }
-  if (!efforts.length) {
-    for (const id of Object.keys(raw)) {
-      if (typeof id === "string" && id) efforts.push({ id, name: id });
-    }
-  }
+  const efforts = Object.keys(raw).filter((id) => id && typeof raw[id] === "string")
+    .map((id) => ({ id, name: id }));
   if (!efforts.length) return undefined;
   return {
     efforts,
-    defaultEffort: efforts.find((row) => row.id !== "off")?.id ?? efforts[0].id,
   };
 }
 
@@ -70,7 +60,6 @@ export function modelSwitchSelection(group, model) {
   return {
     provider: group.id,
     model: model.id,
-    ...(model.reasoning?.defaultEffort === undefined ? {} : { reasoningEffort: model.reasoning.defaultEffort }),
   };
 }
 
@@ -103,9 +92,7 @@ export function effortMenuRows(reasoning, defaultLabel) {
 export function effortMenuItems(reasoning) {
   if (reasoning === undefined) return [];
   const items = [];
-  if (reasoning.defaultEffort === undefined) {
-    items.push({ id: undefined, providerDefault: true });
-  }
+  items.push({ id: undefined, providerDefault: true });
   for (const effort of reasoning.efforts) {
     items.push({
       id: effort.id,
@@ -142,7 +129,7 @@ export function composerModelsFromCatalog(catalog, selection) {
     const provider = typeof group?.id === "string" ? group.id : "";
     if (!provider) continue;
     for (const model of group.models ?? []) {
-      if (!model?.id) continue;
+      if (!model?.id || model.id === "default") continue;
       models.push({
         provider,
         providerName: group.name || provider,

package/router/stt.js

@@ -92,11 +92,12 @@ const RESOLVED_TTL_MS = 120_000;
 export async function listModels(options) {
   try {
     const { rows } = await catalogCache.get({ refresh: options?.refresh });
-    return rows.map(({ id, mode, supportsStt, supportsTts }) => ({
+    return rows.map(({ id, mode, supportsStt, supportsTts, supportsSttStream }) => ({
       id,
       mode,
       supportsStt: Boolean(supportsStt),
       supportsTts: Boolean(supportsTts),
+      supportsSttStream: Boolean(supportsSttStream),
     }));
   } catch (err) {
     const status = err && typeof err === "object" && "status" in err ? Number(err.status) : 503;

package/router/tts.js

@@ -1,3 +1,4 @@
+import { fetchTtsVoices } from "../voice/tts-voice.js";
 import { VoiceError } from "./stt.js";
 import { routerShimBaseUrl } from "./gateway.js";
 
@@ -5,26 +6,10 @@ const REQUEST_TIMEOUT_MS = 180_000;
 
 const PCM_RATE = 24000;
 
-/**
- * Engines pick a speaker per request when none is named, so the readout voice
- * changed between answers. First listed voice the model offers wins.
- */
-const PREFERRED_VOICES = ["serena", "vivian", "uncle_fu"];
-
-export function pickTtsVoice(voices) {
-  const ids = voices.filter((id) => typeof id === "string" && id);
-  return PREFERRED_VOICES.find((id) => ids.includes(id)) ?? [...ids].sort()[0] ?? null;
-}
-
-/** @returns {Promise<string[]>} voice ids the model serves; empty when it lists none. */
+/** @returns {Promise<string[]>} Exact preset IDs; failures remain distinguishable from no presets. */
 export async function listTtsVoices(model) {
-  const res = await fetch(`${routerShimBaseUrl()}/audio/voices?model=${encodeURIComponent(model)}`, {
-    signal: AbortSignal.timeout(10_000),
-  });
-  if (!res.ok) return [];
-  const body = await res.json().catch(() => null);
-  const voices = Array.isArray(body?.voices) ? body.voices : [];
-  return voices.map((voice) => (typeof voice === "string" ? voice : voice?.id));
+  const voices = await fetchTtsVoices(model, { fetcher: (path, options) => fetch(`${routerShimBaseUrl()}${path.replace("/llm/v1", "")}`, options) });
+  return voices.map(row => row.id);
 }
 
 /** Kokoro concatenates chunks with no gap. This is the silence we insert between sentences. */
@@ -132,11 +117,19 @@ export async function synthesizeStream(request, onChunk) {
   if (!type.includes("audio/l16")) {
     return { streamed: false, audio: Buffer.from(await res.arrayBuffer()) };
   }
+  const sampleRate = Number(res.headers.get("x-audio-sample-rate"));
+  if (!Number.isInteger(sampleRate) || sampleRate < 8000 || sampleRate > 192000) throw new VoiceError("voice_audio_format", 502, "missing or invalid PCM sample rate");
+  await request.onFormat?.({ sampleRate, channels: 1, encoding: "pcm_s16le" });
   const reader = res.body.getReader();
+  try {
   while (true) {
     const { done, value } = await reader.read();
     if (done) break;
     if (value?.byteLength) await onChunk(Buffer.from(value));
   }
-  return { streamed: true };
+  } finally {
+    await reader.cancel().catch(() => {});
+    reader.releaseLock();
+  }
+  return { streamed: true, sampleRate };
 }

package/voice/activity.js

@@ -0,0 +1,10 @@
+const active = new Set(), listeners = new Set();
+export const voiceActivity = {
+  getSnapshot: () => active.size > 0,
+  subscribe(listener) { listeners.add(listener); return () => listeners.delete(listener); },
+};
+export function setVoiceActivity(source, busy) {
+  const previous = active.size > 0;
+  busy ? active.add(source) : active.delete(source);
+  if (previous !== (active.size > 0)) for (const listener of listeners) listener();
+}

package/voice/agent-session.js

@@ -65,6 +65,10 @@ export function createVoiceAgentSession(api, { sessionId = null, preset, workspa
         task.firstTextAt = Date.now();
         metric({ stage: "agent_first_text", requestId: task.requestId, durationMs: task.firstTextAt - task.at });
       }
+      if (!replay && task.utterance?.done && !task.utterance.silent && !task.speechReadyAt) {
+        task.speechReadyAt = Date.now();
+        metric({ stage: "agent_speech_ready", requestId: task.requestId, durationMs: task.speechReadyAt - task.at });
+      }
       if (!replay && task.requestId === latestRequest) { utterance = task.utterance; error = task.error; }
     }
     if (event.type === "turn/end" && openTurn === event.data?.turn) { openTurn = null; observedRunning = false; }

package/voice/browser-capture.js

@@ -32,17 +32,58 @@ async function openDeviceMic(mediaDevices) {
   }
 }
 
+/** Request permission in the user gesture; transfer ownership to exactly one recorder. */
+export function prepareBrowserCapture({ media, onTrace = () => {}, now = Date.now } = {}) {
+  let stream = null, cancelled = false, consumed = false;
+  const started = now();
+  const devices = media?.mediaDevices ?? globalThis.navigator?.mediaDevices;
+  const ready = (async () => {
+    if (!devices?.getUserMedia) throw new Error("voice_unsupported");
+    const pending = openDeviceMic(devices);
+    try { onTrace("permission-request", { durationMs: now() - started }); } catch { /* Telemetry is optional. */ }
+    const next = await pending;
+    try { onTrace("permission", { durationMs: now() - started }); } catch { /* Telemetry is optional. */ }
+    if (cancelled) { next.getTracks().forEach(track => track.stop()); return null; }
+    stream = next;
+    return next;
+  })();
+  // Permission may fail while other initialization is still pending.
+  void ready.catch(() => {});
+  return {
+    recording() {
+      try { onTrace("ready", { durationMs: now() - started }); } catch { /* Telemetry is optional. */ }
+    },
+    async consume() {
+      if (consumed || cancelled) throw new Error("voice_cancelled");
+      consumed = true;
+      const next = await ready;
+      if (cancelled || !next) throw new Error("voice_cancelled");
+      stream = null;
+      return next;
+    },
+    cancel() {
+      cancelled = true;
+      stream?.getTracks().forEach(track => track.stop());
+      stream = null;
+    },
+  };
+}
+
 export function createVoiceCapture({
   transcribe,
+  streamInput,
   submit,
   onStream,
   onPhase,
   onTrace,
   now = Date.now,
   media,
+  preparation,
 }) {
   const mediaDevices = media?.mediaDevices ?? globalThis.navigator?.mediaDevices;
   const Recorder = media?.MediaRecorder ?? globalThis.MediaRecorder;
+  let inputAbort = null;
+  let streaming = null;
   let recorder = null;
   let detector = null;
   let stream = null;
@@ -86,10 +127,10 @@ export function createVoiceCapture({
     recorder = null;
   };
 
-  const fail = (code) => {
+  const fail = (code, extra = {}) => {
     if (dead) return;
     if (errorTimer) clearTimeout(errorTimer);
-    emit("error", { error: code, elapsed: 0 });
+    emit("error", { error: code, elapsed: 0, ...extra });
     errorTimer = setTimeout(() => {
       errorTimer = 0;
       if (!dead && phase === "error") emit("idle", { error: "", elapsed: 0 });
@@ -106,6 +147,7 @@ export function createVoiceCapture({
     chunks = [];
     release();
     if (cancel) {
+      streaming?.cancel(); streaming = null;
       emit("idle", { error: "", elapsed: 0 });
       return;
     }
@@ -119,11 +161,12 @@ export function createVoiceCapture({
     emit("transcribing", { elapsed: took, error: "" });
     abort = new AbortController();
     try {
-      const text = String(await transcribe(blob, abort.signal) ?? "").trim();
+      const text = String(await (streaming ? streaming.finish() : transcribe(blob, abort.signal)) ?? "").trim();
+      streaming = null;
       if (dead || cancel) return;
       if (!text) {
         trace("no-input", {});
-        fail("voice_no_input");
+        fail("voice_no_input", { recognizedEmpty: true });
         return;
       }
       trace("transcript", { chars: text.length });
@@ -171,9 +214,11 @@ export function createVoiceCapture({
     async start() {
       if (dead || phase === "preparing" || phase === "recording" || phase === "transcribing") return;
       if (typeof Recorder === "undefined" || !mediaDevices?.getUserMedia) {
+        preparation?.cancel();
         fail("voice_unsupported");
         return;
       }
+      inputAbort = new AbortController();
       cancel = false;
       released = false;
       finished = false;
@@ -181,8 +226,9 @@ export function createVoiceCapture({
       emit("preparing", { elapsed: 0, error: "" });
       let next;
       try {
-        next = await openDeviceMic(mediaDevices);
+        next = await (preparation ? preparation.consume() : openDeviceMic(mediaDevices));
       } catch (err) {
+        preparation?.cancel();
         const code = micFailure(err);
         trace("mic-fail", { code, name: err?.name || "" });
         if (!dead) fail(code);
@@ -208,7 +254,11 @@ export function createVoiceCapture({
         if (recorder?.state === "inactive") scheduleFinish();
       };
       recorder.onstop = () => scheduleFinish();
-      try { detector = await onStream?.(stream); } catch { release(); fail("voice_unsupported"); return; }
+      try {
+        const nextDetector = await onStream?.(stream);
+        if (dead || cancel) { nextDetector?.stop?.(); release(); return; }
+        detector = nextDetector;
+      } catch (error) { release(); if (!dead && !cancel) fail(error.message || "voice_unsupported"); return; }
       started = now();
       try {
         recorder.start(CHUNK_MS);
@@ -224,7 +274,18 @@ export function createVoiceCapture({
         return;
       }
       emit("recording", { elapsed: 0, error: "" });
+      preparation?.recording();
       timer = setInterval(() => emit("recording", { elapsed: now() - started, error: "" }), 200);
+      // The recognizer socket is not the microphone. A take that is already
+      // recording keeps its blob when the socket is still closed.
+      const pending = streamInput?.(stream, { signal: inputAbort.signal, onPartial: (text) => emit(phase, { partial: text }) });
+      if (pending && typeof pending.then === "function") {
+        pending.then((port) => {
+          if (!port) return;
+          if (dead || cancel || finished || released || chunks.length) { port.cancel?.(); return; }
+          streaming = port;
+        }, () => {});
+      } else if (pending) streaming = pending;
     },
     /**
      * Finger-up finishes the take. The mic opens asynchronously, so the finger
@@ -235,6 +296,7 @@ export function createVoiceCapture({
         if (aborting) {
           cancel = true;
           abort?.abort();
+          streaming?.cancel(); streaming = null;
         }
         return;
       }
@@ -248,6 +310,7 @@ export function createVoiceCapture({
         recorder: recorder?.state || "none",
       });
       if (aborting) {
+        inputAbort?.abort();
         cancel = true;
         released = false;
         if (recorder && recorder.state !== "inactive") recorder.stop();
@@ -261,12 +324,15 @@ export function createVoiceCapture({
       }
     },
     dispose() {
+      preparation?.cancel();
+      inputAbort?.abort();
       dead = true;
       cancel = true;
       if (errorTimer) clearTimeout(errorTimer);
       if (finishTimer) clearTimeout(finishTimer);
       stopTimer();
       abort?.abort();
+      streaming?.cancel(); streaming = null;
       if (recorder && recorder.state !== "inactive") recorder.stop();
       release();
     },

package/voice/browser-playback.js

@@ -1,28 +1,24 @@
 export function createBrowserPlayer() {
-  let element = null;
-  let finish = null;
-  const stop = () => {
-    element?.pause();
-    finish?.();
-  };
+  let element = null, finish = null, paused = false;
+  const stop = () => { paused = false; element?.pause(); finish?.(); };
   return {
+    canPause: true,
+    pause() { paused = true; element?.pause(); },
+    resume() { paused = false; return element?.play(); },
     play(blob) {
-      stop();
-      return new Promise((resolve) => {
-        const url = URL.createObjectURL(blob);
-        const audio = new Audio(url);
-        const done = () => {
+      const preservePause = paused;
+      stop(); paused = preservePause;
+      return new Promise((resolve, reject) => {
+        const url = URL.createObjectURL(blob), audio = new Audio(url);
+        const done = (error) => {
           if (finish !== done) return;
-          finish = null;
-          element = null;
-          URL.revokeObjectURL(url);
-          resolve();
+          finish = null; element = null; URL.revokeObjectURL(url);
+          error ? reject(error) : resolve();
         };
-        element = audio;
-        finish = done;
-        audio.addEventListener("ended", done, { once: true });
-        audio.addEventListener("error", done, { once: true });
-        audio.play().catch(done);
+        element = audio; finish = done;
+        audio.addEventListener("ended", () => done(), { once: true });
+        audio.addEventListener("error", () => done(new Error("voice_playback_failed")), { once: true });
+        if (!paused) audio.play().catch(done);
       });
     },
     stop,

package/voice/client.js

@@ -4,6 +4,9 @@ import { createSnapshotStore } from "../tools/async.js";
 export const API = "/api/lares/voice";
 
 const settings = createSnapshotStore();
+const diagnostics = createSnapshotStore();
+let configRevision = 0;
+let confirmedConfig = null;
 export const voiceClientId = mintRpcId();
 export function voiceHeaders(device) {
   const selected = device ?? settings.peek()?.config?.device;
@@ -16,26 +19,33 @@ export function rememberedVoiceSettings() {
 
 export async function loadVoiceSettings(options = {}) {
   const query = options.force ? "?refresh=1" : "";
-  return settings.load(async () => {
-    const [config, status, models] = await Promise.all([
-      getJson("/config"),
-      getJson(`/status${query}`),
-      getJson(`/models${query}`),
-    ]);
+  const value = await settings.load(async () => {
+    const revision = configRevision;
+    const [config, models] = await Promise.all([getJson("/config"), getJson(`/capabilities${query}`)]);
+    if (revision === configRevision) confirmedConfig = config;
+    const selected = models.selected || "";
     return {
-      config,
-      status,
+      config: confirmedConfig || config,
+      status: { ok: Boolean(selected), modelAvailable: Boolean(selected), model: selected, language: config.language },
       sttModels: Array.isArray(models.stt) ? models.stt : [],
       ttsModels: Array.isArray(models.tts) ? models.tts : [],
+      ttsSelected: models.ttsSelected || "",
+      ttsDefault: models.ttsDefault || "",
       chatModels: Array.isArray(models.chat) ? models.chat : [],
       realtimeModels: Array.isArray(models.realtime) ? models.realtime : [],
       realtimeReady: Array.isArray(models.realtimeReady) ? models.realtimeReady : [],
-      charts: {
-        stt: chartView(models.charts?.stt),
-        tts: chartView(models.charts?.tts),
-      },
     };
   }, options);
+  if (options.diagnostics === false) return value;
+  try {
+    const detail = await diagnostics.load(async () => {
+      const [status, models] = await Promise.all([getJson(`/status${query}`), getJson(`/models${query}`)]);
+      return { status, charts: models.charts ? { stt: chartView(models.charts.stt), tts: chartView(models.charts.tts) } : null, diagnosticsError: models.charts ? null : "voice_failed" };
+    }, options);
+    return { ...settings.peek(), ...detail };
+  } catch (error) {
+    return { ...settings.peek(), ...diagnostics.peek(), diagnosticsError: error.message };
+  }
 }
 
 function chartView(row) {
@@ -109,9 +119,13 @@ export async function saveVoiceSettings(patch) {
     body: JSON.stringify(patch),
   });
   if (!res.ok) throw new Error(String(res.status));
-  const next = await loadVoiceSettings({ force: true });
+  const config = await res.json();
+  configRevision++;
+  confirmedConfig = config;
+  const previous = settings.peek();
+  const next = previous ? settings.remember({ ...previous, config }) : await loadVoiceSettings({ diagnostics: false });
   globalThis.window?.dispatchEvent?.(new Event("lares-voice-settings"));
-  return next;
+  return { ...next, ...diagnostics.peek() };
 }
 
 /** Reading mode and the GPU slicing it needs; see core/voice/gpu-mode.js. */

package/voice/composite-gateway.js

@@ -56,10 +56,14 @@ export function createCompositeGateway({ service, config, transcribe, synthesize
           send({ type: "response.output_audio_transcript.delta", response_id: id, delta: text });
           if (!audioOutput) { done(id); return; }
           scope.outputAbort = new AbortController();
-          const audio = await synthesize(text, scope);
+          const output = async (audio) => {
+            if (closed || epoch !== generation) return;
+            awaitingPlayback = true;
+            for (let offset = 0; offset < audio.length; offset += 24000) send({ type: "response.output_audio.delta", response_id: id, item_id: id, delta: audio.subarray(offset, offset + 24000).toString("base64") });
+          };
+          const audio = await synthesize(text, scope, output);
           if (closed || epoch !== generation) return;
-          awaitingPlayback = true;
-          for (let offset = 0; offset < audio.length; offset += 24000) send({ type: "response.output_audio.delta", response_id: id, item_id: id, delta: audio.subarray(offset, offset + 24000).toString("base64") });
+          if (audio) await output(audio);
           send({ type: "response.output_audio.done", response_id: id });
           done(id);
         };