@olares/lares-core 0.15.9 → 0.15.11

package/i18n/voice.js

@@ -24,22 +24,67 @@ export const ZH = {
   "mic.idle": "语音输入",
   "mic.blocked": "当前无法输入",
   "lang.auto": "自动检测",
-  "status.auto": "自动",
   "settings.title": "语音设置",
-  "settings.intro": "点击麦克风开始说话，说完自动转成文字。语音播报开启后，只朗读这一轮的最终回答。",
   "settings.refresh": "刷新",
   "settings.refreshing": "刷新中…",
   "settings.router": "Router 控制台",
   "settings.loading": "正在读取语音设置…",
   "settings.loadFailed": "读取语音设置失败",
   "settings.refreshFailed": "刷新语音模型列表失败",
-  "settings.status.ready": "识别就绪 · {model}",
-  "settings.status.notReady": "还没有语音识别模型",
   "settings.stt.title": "语音识别",
   "settings.stt.hint": "把麦克风里的话转成文字",
   "settings.tts.title": "语音播报",
   "settings.tts.hint": "只朗读最终回答，思考和工具调用不播报",
   "settings.speak.label": "开启语音播报",
+  "settings.group.stt": "语音识别",
+  "settings.group.tts": "语音播报",
+  "settings.group.bluetooth": "输出设备",
+  "settings.stt.model": "识别模型",
+  "settings.tts.model": "播报模型",
+  "settings.speak.title": "自动朗读回答",
+  "settings.phase.running": "运行中",
+  "settings.phase.stopped": "已停止",
+  "settings.phase.busy": "处理中",
+  "settings.phase.failed": "异常",
+  "settings.phase.absent": "未安装",
+  "settings.mode.title": "播报方式",
+  "settings.mode.hint": "边写边读用显存分片，写完再读用时间分片。切换约 2–3 分钟，期间模型不可用",
+  "settings.mode.gpu": "显卡：{type}",
+  "settings.mode.turns": "写完再读",
+  "settings.mode.streaming": "边写边读",
+  "settings.mode.switching": "正在切换显卡模式…",
+  "settings.mode.resumingApp": "正在恢复 {app}…",
+  "settings.mode.partial": "显卡已切换，但这些应用没能恢复：{apps}",
+  "settings.mode.failed": "切换显卡模式失败：{error}",
+  "settings.mode.mismatch": "显卡当前是{type}，和播报方式不一致",
+  "settings.mode.noGpu": "没有找到 NVIDIA 显卡",
+  "settings.mode.retry": "重试",
+  "settings.gpu.MemorySlice": "显存分片",
+  "settings.gpu.TimeSlice": "时间分片",
+  "settings.gpu.Exclusive": "独占",
+  "settings.apps.title": "显卡应用",
+  "settings.apps.hint": "时间分片下这些应用轮流使用整张显卡；同时运行太多，显存可能不够",
+  "settings.apps.required": "至少 {size} GiB 显存",
+  "settings.apps.start": "启动",
+  "settings.apps.stop": "停止",
+  "settings.apps.starting": "启动中…",
+  "settings.apps.stopping": "停止中…",
+  "settings.apps.empty": "没有需要显卡的应用",
+  "settings.slices.title": "显存分片",
+  "settings.slices.gpu": "显卡",
+  "settings.slices.used": "已分配 {used} / {total} GiB",
+  "settings.slices.hint": "选择哪些应用常驻显卡、各分多少显存。保存后只重启有改动的应用",
+  "settings.slices.hintPending": "切到边写边读时，按这里的配置分配显存",
+  "settings.slices.size": "{app}的显存",
+  "settings.slices.enable": "{app}参与显存分片",
+  "settings.slices.empty": "还没有应用绑定到这张显卡",
+  "settings.slices.over": "超出显卡显存 {over} GiB",
+  "settings.slices.invalid": "开启的应用显存不能低于它的最低要求",
+  "settings.slices.restart": "有改动的应用会重启",
+  "settings.slices.reset": "还原",
+  "settings.slices.save": "保存",
+  "settings.slices.apply": "保存并应用",
+  "settings.slices.saving": "保存中…",
   "settings.install": "安装",
   "settings.installing": "安装中…",
   "settings.installStarted": "已开始安装，模型下载完成后点刷新",
@@ -94,23 +139,67 @@ export const EN = {
   "mic.idle": "Voice input",
   "mic.blocked": "Input unavailable",
   "lang.auto": "Auto-detect",
-  "status.auto": "auto",
   "settings.title": "Voice settings",
-  "settings.intro":
-    "Click the microphone to start speaking; the take is transcribed into the composer. With playback on, only the turn's final answer is spoken.",
   "settings.refresh": "Refresh",
   "settings.refreshing": "Refreshing…",
   "settings.router": "Router console",
   "settings.loading": "Loading voice settings…",
   "settings.loadFailed": "Failed to load voice settings",
   "settings.refreshFailed": "Failed to refresh voice models",
-  "settings.status.ready": "Recognition ready · {model}",
-  "settings.status.notReady": "No speech-recognition model yet",
   "settings.stt.title": "Speech recognition",
   "settings.stt.hint": "Turn the microphone into text",
   "settings.tts.title": "Speech playback",
   "settings.tts.hint": "Read only the final answer, not reasoning or tool calls",
   "settings.speak.label": "Speak the final answer",
+  "settings.group.stt": "Speech recognition",
+  "settings.group.tts": "Speech playback",
+  "settings.group.bluetooth": "Output device",
+  "settings.stt.model": "Recognition model",
+  "settings.tts.model": "Speech model",
+  "settings.speak.title": "Read answers aloud",
+  "settings.phase.running": "Running",
+  "settings.phase.stopped": "Stopped",
+  "settings.phase.busy": "Working",
+  "settings.phase.failed": "Failed",
+  "settings.phase.absent": "Not installed",
+  "settings.mode.title": "Reading mode",
+  "settings.mode.hint": "While writing uses memory slicing; when done uses time slicing. Switching takes 2–3 minutes; models are unavailable meanwhile",
+  "settings.mode.gpu": "GPU: {type}",
+  "settings.mode.turns": "When done",
+  "settings.mode.streaming": "While writing",
+  "settings.mode.switching": "Switching GPU mode…",
+  "settings.mode.resumingApp": "Resuming {app}…",
+  "settings.mode.partial": "GPU switched, but these apps did not resume: {apps}",
+  "settings.mode.failed": "GPU switch failed: {error}",
+  "settings.mode.mismatch": "The GPU is in {type}, which does not match the reading mode",
+  "settings.mode.noGpu": "No NVIDIA GPU found",
+  "settings.mode.retry": "Retry",
+  "settings.gpu.MemorySlice": "memory slicing",
+  "settings.gpu.TimeSlice": "time slicing",
+  "settings.gpu.Exclusive": "exclusive",
+  "settings.apps.title": "GPU apps",
+  "settings.apps.hint": "With time slicing these apps take turns on the whole GPU; running too many at once may run out of memory",
+  "settings.apps.required": "needs {size} GiB",
+  "settings.apps.start": "Start",
+  "settings.apps.stop": "Stop",
+  "settings.apps.starting": "Starting…",
+  "settings.apps.stopping": "Stopping…",
+  "settings.apps.empty": "No apps need the GPU",
+  "settings.slices.title": "Memory slices",
+  "settings.slices.gpu": "GPU",
+  "settings.slices.used": "{used} / {total} GiB allocated",
+  "settings.slices.hint": "Choose which apps stay on the GPU and how much memory each gets. Saving restarts only the apps that changed",
+  "settings.slices.hintPending": "Applied when switching to reading while writing",
+  "settings.slices.size": "Memory for {app}",
+  "settings.slices.enable": "{app} uses a memory slice",
+  "settings.slices.empty": "No apps are bound to this GPU yet",
+  "settings.slices.over": "{over} GiB over the GPU memory",
+  "settings.slices.invalid": "An enabled app cannot go below its minimum memory",
+  "settings.slices.restart": "Apps that changed will restart",
+  "settings.slices.reset": "Reset",
+  "settings.slices.save": "Save",
+  "settings.slices.apply": "Save and apply",
+  "settings.slices.saving": "Saving…",
   "settings.install": "Install",
   "settings.installing": "Installing…",
   "settings.installStarted": "Install started. Refresh after the model finishes downloading",

package/larepass/host.js

@@ -3,6 +3,12 @@ export const LARES_API_PREFIX = "/api/lares";
 export const MODELS_PATH = `${LARES_API_PREFIX}/models`;
 export const PC_TEST_PROXY = "/laresHost";
 
+/**
+ * Packaged LarePass page origins (Capacitor Android `androidScheme: http`, iOS).
+ * Binary bodies leave those pages as a cross-origin webview `fetch`.
+ */
+export const LAREPASS_PAGE_ORIGINS = ["http://localhost", "https://localhost", "capacitor://localhost"];
+
 /** Host plugin routes (`file-preview`, models, voice, …). Same path on PC and LarePass. */
 export function isLaresPluginPath(path) {
   const suffix = String(path ?? "").startsWith("/") ? path : `/${path}`;

package/larepass/mux.js

@@ -77,11 +77,12 @@ export function classifyRemoteEvent(value) {
   return { kind: "pass", eventId: value.eventId };
 }
 
+// A tool call starting is what turns the step being read aloud silent.
+const LIVE_CHUNKS = new Set(["text-delta", "reasoning-delta", "tool-call-delta", "block-end"]);
+
 function liveChunkEvent(seq, turn, step, chunk) {
   if (!chunk || typeof chunk !== "object") return null;
-  if (chunk.type !== "text-delta" && chunk.type !== "reasoning-delta" && chunk.type !== "block-end") {
-    return null;
-  }
+  if (!LIVE_CHUNKS.has(chunk.type)) return null;
   return {
     type: "assistant/chunk",
     seq,

package/larepass/runtime.js

@@ -47,7 +47,7 @@ function viewOf(state, cache, pendingQuestions, pendingApprovals, inbox) {
     messages: snap.messages,
     running: snap.running,
     runningSince: snap.runningSince,
-    reply: snap.reply,
+    utterance: snap.utterance,
     error: state.error || snap.error,
     failed: state.failed,
     phase: state.phase,
@@ -872,9 +872,9 @@ export function createChatRuntime(client) {
       if (typeof client.reportLog !== "function") return Promise.resolve(false);
       return client.reportLog(scope, event, fields);
     },
-    speak(text) {
+    speak(request) {
       if (typeof client.speak !== "function") return Promise.resolve(null);
-      return client.speak(text);
+      return client.speak(request);
     },
     interruptSpeech() {
       if (typeof client.interruptSpeech !== "function") return Promise.resolve(false);

package/larepass/transcript.js

@@ -1,6 +1,6 @@
 import { producedPathsFromView, turnMediaPathsFromEvent } from "../files/deliverables.js";
 import { durablePathFromToolCall, parseToolArguments } from "../files/published-tools.js";
-import { concludingReply } from "../voice/speech.js";
+import { reduceUtterance } from "../voice/speech.js";
 import { contextForm, contextProvenance, isHumanUserSource } from "./context-provenance.js";
 import { toolRowModel } from "./tool-row.js";
 import { createTurnMetrics } from "./turn-metrics.js";
@@ -111,7 +111,7 @@ export function foldTranscript(entries) {
   let running = false;
   let runningSince = 0;
   let error = "";
-  let reply = null;
+  let utterance = null;
   let streamCursor = { loc: "", kind: "", index: 0 };
   let activeTurn = 0;
   const ended = new Map();
@@ -238,6 +238,7 @@ export function foldTranscript(entries) {
     const data = event.data ?? {};
     const view = entryView(entry, event);
     metrics.observe(event);
+    utterance = reduceUtterance(utterance, event);
 
     if (event.type === "turn/start") {
       closeTurn();
@@ -248,7 +249,6 @@ export function foldTranscript(entries) {
       running = true;
       runningSince = Number(event.time) || 0;
       error = "";
-      reply = null;
       continue;
     }
 
@@ -280,8 +280,6 @@ export function foldTranscript(entries) {
 
     if (event.type === "assistant/message") {
       applyAssistantMessage(data);
-      const text = concludingReply(event);
-      if (text) reply = { seq: event.seq, text };
       continue;
     }
 
@@ -376,6 +374,6 @@ export function foldTranscript(entries) {
     running,
     runningSince: running ? runningSince : 0,
     error,
-    reply,
+    utterance,
   };
 }

package/log/report.js

@@ -0,0 +1,46 @@
+/** Client diagnostics. One record shape, whether it is written here or posted in. */
+
+export const REPORT_PATH = "/api/lares/log";
+
+const SCOPE = /^[a-z][a-z0-9-]{0,31}$/;
+const EVENT = /^[a-z][a-z0-9-]{0,39}$/;
+const FIELD = /^[a-z][a-zA-Z0-9]{0,31}$/;
+
+export function reportRecord(input = {}) {
+  const source = input && typeof input === "object" ? input : {};
+  const scope = typeof source.scope === "string" && SCOPE.test(source.scope) ? source.scope : "client";
+  const event = typeof source.event === "string" && EVENT.test(source.event) ? source.event : "event";
+  const record = { scope, event };
+  for (const [key, value] of Object.entries(source)) {
+    if (key === "scope" || key === "event" || !FIELD.test(key)) continue;
+    if (typeof value === "string") record[key] = value.slice(0, 180);
+    else if (typeof value === "number" && Number.isFinite(value)) record[key] = value;
+    else if (typeof value === "boolean") record[key] = value;
+  }
+  return record;
+}
+
+export function writeReport(input) {
+  const record = reportRecord(input);
+  console.log(`[lares:${record.scope}]`, JSON.stringify(record));
+  return record;
+}
+
+/**
+ * Fire-and-forget. `request` is the host port when the page has no cookie.
+ * A rejected port does not reject the caller.
+ */
+export function postReport(input, options = {}) {
+  const body = reportRecord(input);
+  const url = options.url ?? REPORT_PATH;
+  const send = options.request;
+  const pending = typeof send === "function"
+    ? send(url, { method: "POST", headers: { "content-type": "application/json" }, body })
+    : fetch(url, {
+      method: "POST",
+      credentials: "include",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify(body),
+    });
+  return Promise.resolve(pending).then(() => true, () => false);
+}

package/olares/trusted-host.js

@@ -2,9 +2,19 @@ export function loopbackAuthority(port) {
   return `127.0.0.1:${port}`;
 }
 
+/** The browser's Origin, kept for CORS after the loopback rewrite replaces it. */
+const pageOrigins = new WeakMap();
+
+export function pageOrigin(headers) {
+  return pageOrigins.get(headers) ?? headers?.origin;
+}
+
 export function applyLoopbackHeaders(headers, authority) {
   headers.host = authority;
-  if (headers.origin !== undefined) headers.origin = `http://${authority}`;
+  if (headers.origin !== undefined) {
+    if (!pageOrigins.has(headers)) pageOrigins.set(headers, headers.origin);
+    headers.origin = `http://${authority}`;
+  }
   // Fetch Metadata outlives the origin rewrite. The browser decides this one and
   // we cannot argue with it: a packaged page calling the entrance is `cross-site`
   // however the host and origin now read, and dsh refuses that outright — the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@olares/lares-core",
-  "version": "0.15.9",
+  "version": "0.15.11",
   "description": "Lares 共享业务核心：Router、workspace、文件/媒体、Olares 身份（无 UI、无平台壳）",
   "type": "module",
   "repository": {
@@ -20,6 +20,7 @@
     "i18n",
     "icons",
     "larepass",
+    "log",
     "media",
     "mcp",
     "olares",
@@ -122,6 +123,7 @@
     "./voice/problem": "./voice/problem.js",
     "./voice/capture": "./voice/capture.js",
     "./voice/install": "./voice/install.js",
+    "./voice/gpu-mode": "./voice/gpu-mode.js",
     "./search/config": "./search/config.js",
     "./search/menu": "./search/menu.js",
     "./search/client": "./search/client.js",

package/router/tts.js

@@ -5,6 +5,28 @@ 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. */
+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));
+}
+
 /** Kokoro concatenates chunks with no gap. This is the silence we insert between sentences. */
 export function silencePcm(ms, sampleRate = PCM_RATE) {
   const samples = Math.max(0, Math.round((sampleRate * ms) / 1000));
@@ -47,6 +69,7 @@ export async function synthesize(request) {
         model: request.model,
         input: text,
         response_format: "wav",
+        ...(request.voice ? { voice: request.voice } : {}),
       }),
       signal: AbortSignal.timeout(request.timeoutMs ?? REQUEST_TIMEOUT_MS),
     });
@@ -89,6 +112,7 @@ export async function synthesizeStream(request, onChunk) {
         input: text,
         response_format: "pcm",
         stream: true,
+        ...(request.voice ? { voice: request.voice } : {}),
       }),
       signal,
     });

package/tools/http.js

@@ -1,3 +1,18 @@
+import { LAREPASS_PAGE_ORIGINS } from "../larepass/host.js";
+import { pageOrigin } from "../olares/trusted-host.js";
+
+const CORS_HEADERS = "content-type, x-authorization, x-unauth-error, x-lares-session-id, x-lares-file-name, x-lares-upload-request-id";
+
+/** @returns {boolean} true when the request came from a LarePass page. */
+function allowLarepassOrigin(req, res) {
+  const origin = pageOrigin(req.headers);
+  if (!origin || !LAREPASS_PAGE_ORIGINS.includes(origin)) return false;
+  res.setHeader("access-control-allow-origin", origin);
+  res.setHeader("access-control-allow-credentials", "true");
+  res.setHeader("vary", "Origin");
+  return true;
+}
+
 export class HttpError extends Error {
   constructor(code, status, message) {
     super(message);
@@ -99,12 +114,22 @@ export function createRouteHandler(options) {
     const suffix = new URL(req.url ?? "/", "http://x").pathname.slice(options.prefix.length) || "/";
     const path = suffix.replace(/\/+$/, "") || "/";
     const handlers = options.routes[path];
+    const cors = allowLarepassOrigin(req, res);
     if (!handlers) {
       sendJson(res, 404, {
         error: { code: "not_found", message: `no route ${path}` },
       });
       return;
     }
+    if (cors && method === "OPTIONS") {
+      res.writeHead(204, {
+        "access-control-allow-methods": Object.keys(handlers).join(", "),
+        "access-control-allow-headers": CORS_HEADERS,
+        "access-control-max-age": "600",
+      });
+      res.end();
+      return;
+    }
     const route = handlers[method];
     if (!route) {
       sendJson(res, 405, {

package/voice/client.js

@@ -32,6 +32,7 @@ export async function loadVoiceSettings(options = {}) {
 function chartView(row) {
   const phase = row?.phase;
   return {
+    app: typeof row?.app === "string" ? row.app : "",
     phase: phase === "running" || phase === "stopped" || phase === "busy" || phase === "failed" ? phase : "absent",
     state: typeof row?.state === "string" ? row.state : "",
   };
@@ -62,11 +63,12 @@ export function wavBlob(base64) {
   return new Blob([bytes], { type: "audio/wav" });
 }
 
-export async function postSpeak(text) {
+/** Hands over a streaming answer's text; with `part`, also returns that sentence's audio. */
+export async function postSpeak({ key, text, done, part }) {
   const res = await fetch(`${API}/speak`, {
     method: "POST",
     headers: { "content-type": "application/json" },
-    body: JSON.stringify({ text }),
+    body: JSON.stringify(Number.isInteger(part) ? { key, text, done, part } : { key, text, done }),
   });
   let body = null;
   try {
@@ -74,7 +76,11 @@ export async function postSpeak(text) {
   } catch {
     body = null;
   }
-  if (!res.ok || typeof body?.audio !== "string") throw new Error(transcribeErrorCode(body));
+  if (res.ok && body && !Number.isInteger(part)) return { sentences: Number(body.sentences) || 0 };
+  if (!res.ok || typeof body?.audio !== "string") {
+    const code = transcribeErrorCode(body);
+    throw Object.assign(new Error(code), { code });
+  }
   return {
     bluetooth: body.bluetooth === "played" ? "played" : "skipped",
     blob: wavBlob(body.audio),
@@ -97,6 +103,47 @@ export async function saveVoiceSettings(patch) {
   return loadVoiceSettings({ force: true });
 }
 
+/** Reading mode and the GPU slicing it needs; see core/voice/gpu-mode.js. */
+export async function loadGpuMode() {
+  const res = await fetch(`${API}/gpu-mode`);
+  if (!res.ok) throw new Error(String(res.status));
+  return res.json();
+}
+
+export async function switchGpuMode(streaming) {
+  const res = await fetch(`${API}/gpu-mode`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ streaming }),
+  });
+  if (!res.ok) throw new Error(String(res.status));
+  return res.json();
+}
+
+/** @param {{ app: string, enabled: boolean, memory: number }[]} apps memory in bytes */
+export async function saveSlicePlan(apps) {
+  const res = await fetch(`${API}/gpu-mode/slices`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ apps }),
+  });
+  const payload = await res.json().catch(() => null);
+  if (!res.ok) throw Object.assign(new Error(payload?.error?.message || String(res.status)), { code: payload?.error?.code });
+  return payload;
+}
+
+/** @param {string} app @param {"resume" | "stop"} op */
+export async function postGpuApp(app, op) {
+  const res = await fetch(`${API}/gpu-mode/app`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({ app, op }),
+  });
+  const payload = await res.json().catch(() => null);
+  if (!res.ok) throw new Error(payload?.error?.message || String(res.status));
+  return payload;
+}
+
 function transcribeErrorCode(payload) {
   const code = payload && typeof payload === "object" ? payload.error?.code : undefined;
   return typeof code === "string" ? code : "voice_failed";

package/voice/config.js

@@ -9,6 +9,8 @@ const DEFAULTS = {
   ttsModel: "",
   language: "",
   speak: false,
+  // Read answers while they are written. Needs the GPU in MemorySlice, see gpu-mode.js.
+  streaming: false,
 };
 
 const WRITABLE = new Set(Object.keys(DEFAULTS));
@@ -25,9 +27,9 @@ export function validateConfigPatch(raw) {
   const patch = {};
   for (const [key, value] of Object.entries(raw)) {
     if (!WRITABLE.has(key)) invalid(`unknown voice setting: ${key}`);
-    if (key === "speak") {
-      if (typeof value !== "boolean") invalid("speak must be a boolean");
-      patch.speak = value;
+    if (key === "speak" || key === "streaming") {
+      if (typeof value !== "boolean") invalid(`${key} must be a boolean`);
+      patch[key] = value;
       continue;
     }
     if (typeof value !== "string") invalid(`${key} must be a string`);
@@ -54,6 +56,7 @@ export function readConfig() {
   if (SAFE_MODEL.test(ttsModel)) merged.ttsModel = ttsModel;
   if (SUPPORTED_LANGUAGES.has(language)) merged.language = language;
   if (stored?.speak === true) merged.speak = true;
+  if (stored?.streaming === true) merged.streaming = true;
   return merged;
 }