friend-assistant 0.1.41 → 0.1.42

package/dist/BUILD.json

@@ -1,5 +1,5 @@
 {
   "name": "friend-assistant",
-  "version": "0.1.41",
-  "builtAt": "2026-10-13T04:06:44.122Z"
+  "version": "0.1.42",
+  "builtAt": "2026-10-13T05:30:33.387Z"
 }

package/dist/friend.mjs

@@ -159,6 +159,14 @@ function resolveVoice(input) {
   if (PLAIN.test(t) && PIPER_NAME.test(t)) return { id: t, label: t, listed: false };
   return null;
 }
+var LISTENING_MODELS = [
+  { id: "tiny", name: "Tiny", mb: 75, note: "fastest, mishears a lot" },
+  { id: "base", name: "Base", mb: 145, note: "fast, struggles with Hindi, Marathi and distance" },
+  { id: "small", name: "Small", mb: 480, note: "recommended: much better, still quick" },
+  { id: "medium", name: "Medium", mb: 1500, note: "better again, slow on a PC without a graphics card" },
+  { id: "large-v3-turbo", name: "Large (turbo)", mb: 1600, note: "most accurate for Marathi; needs a fast PC" }
+];
+var downloadSize = (mb) => `about ${mb >= 1e3 ? `${(mb / 1e3).toFixed(1)} GB` : `${mb} MB`}`;
 
 // ../protocol/src/themes.ts
 var THEMES = [
@@ -12970,7 +12978,7 @@ function refuseForAgent(raw) {
   if ("command" in cc) throw new SettingsError("The Claude Code command can only be changed by the owner on the settings screen.");
 }
 var PROVIDER_KEYS = /* @__PURE__ */ new Set(["provider", "model", "apiKey", "ollama", "openai", "claudeCode"]);
-var RESTART_VOICE = ["enabled", "sttModel"];
+var RESTART_VOICE = ["enabled"];
 function applySettings(config, raw) {
   const parsed = SettingsPatch.safeParse(raw);
   if (!parsed.success) {
@@ -13852,7 +13860,11 @@ var HttpVoiceService = class {
     });
     return Buffer.from(await res.arrayBuffer());
   }
-  async request(path3, init) {
+  /** Loading a model the first time downloads it (up to about 1.6 GB), so this waits far longer than a normal request. */
+  async useListeningModel(name) {
+    await this.request("/stt-model", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ model: name }) }, 30 * 6e4);
+  }
+  async request(path3, init, timeoutMs) {
     const base = this.opts.baseUrl();
     if (!base) throw new VoiceError("the voice sidecar is not running");
     let res;
@@ -13860,7 +13872,7 @@ var HttpVoiceService = class {
       res = await fetch(base + path3, {
         ...init,
         headers: { ...init.headers, authorization: `Bearer ${this.opts.token}` },
-        signal: AbortSignal.timeout(this.opts.timeoutMs ?? 6e4)
+        signal: AbortSignal.timeout(timeoutMs ?? this.opts.timeoutMs ?? 6e4)
       });
     } catch (e) {
       if (e.name === "TimeoutError") throw new VoiceError("the voice sidecar timed out");
@@ -14379,6 +14391,7 @@ async function createApp(opts) {
   function commitSettings(patch, how) {
     let applied;
     let voiceBefore = config.voice.ttsVoice;
+    let sttBefore = config.voice.sttModel;
     try {
       const saved = loadConfig(opts.dataDir);
       const check3 = applySettings(saved, patch);
@@ -14386,6 +14399,7 @@ async function createApp(opts) {
         throw new HttpError(409, "Friend is busy with a request. Change the model when it is done.");
       }
       voiceBefore = config.voice.ttsVoice;
+      sttBefore = config.voice.sttModel;
       applied = applySettings(config, patch);
       saveConfig(saved);
     } catch (e) {
@@ -14411,6 +14425,7 @@ async function createApp(opts) {
       else swap();
     }
     if (applied.changed.includes("voice.ttsVoice")) void warmVoice(config.voice.ttsVoice, voiceBefore);
+    if (applied.changed.includes("voice.sttModel")) void warmListening(config.voice.sttModel, sttBefore);
     if (applied.changed.includes("voice.hindiVoice")) void warmLanguageVoice(config.voice.hindiVoice);
     if (applied.changed.includes("voice.marathiVoice")) void warmLanguageVoice(config.voice.marathiVoice);
     if (applied.changed.some((k) => k === "view" || k === "ownerName" || k.startsWith("look.") || k.startsWith("hud") || k.startsWith("music"))) {
@@ -14437,6 +14452,25 @@ async function createApp(opts) {
       broadcast({ type: "alert", level: "warn", text: `Could not load the voice ${wanted} (it needs internet the first time). Using ${voiceLabel(previous)} again.` });
     }
   }
+  async function warmListening(wanted, previous) {
+    if (!voice2?.useListeningModel || !voiceAvailable()) return;
+    const known = LISTENING_MODELS.find((m) => m.id === wanted);
+    const download = known ? ` (${downloadSize(known.mb)} the first time it is downloaded)` : ". The first time it downloads";
+    broadcast({ type: "alert", level: "info", text: `Getting the listening model ${wanted}${download}. Friend keeps listening with the old one meanwhile.` });
+    try {
+      await voice2.useListeningModel(wanted);
+      broadcast({ type: "alert", level: "info", text: `The listening model ${wanted} is ready.` });
+    } catch (e) {
+      audit.log("system", "voice.model_failed", { model: wanted, message: e.message });
+      if (config.voice.sttModel === wanted) {
+        config.voice.sttModel = previous;
+        const saved = loadConfig(opts.dataDir);
+        saved.voice.sttModel = previous;
+        saveConfig(saved);
+      }
+      broadcast({ type: "alert", level: "warn", text: `Could not load the listening model ${wanted} (it needs internet the first time). Using ${previous} again.` });
+    }
+  }
   async function warmLanguageVoice(wanted) {
     if (!wanted || !voice2 || !voiceAvailable()) return;
     broadcast({ type: "alert", level: "info", text: `Loading the voice ${voiceLabel(wanted)}. The first time it downloads about 64 MB.` });
@@ -17844,7 +17878,7 @@ async function daemonCommand(args, io2, deps = realDeps) {
 import crossSpawn5 from "cross-spawn";
 var PACKAGE = "friend-assistant";
 var real = {
-  current: () => true ? "0.1.41" : "development",
+  current: () => true ? "0.1.42" : "development",
   latest: () => new Promise((resolve13) => {
     const child = crossSpawn5("npm", ["view", PACKAGE, "version", "--prefer-online"], { stdio: ["ignore", "pipe", "ignore"] });
     let out = "";
@@ -18132,7 +18166,7 @@ async function run(argv, io2) {
       case "version":
       case "--version":
       case "-v":
-        io2.out(true ? "0.1.41" : "development");
+        io2.out(true ? "0.1.42" : "development");
         return 0;
       case "lan":
         return await lanCommand(rest, io2);

package/dist/voice/friend_voice/__main__.py

@@ -32,7 +32,13 @@ def main() -> int:
 
         engines = load_engines(args.data_dir, args.stt_model, args.tts_voice)
 
-    server, port = make_server(engines, token, port=args.port)
+    if args.fake:
+        loader = lambda name: FakeEngines().stt  # noqa: E731
+    else:
+        from .models import load_stt
+
+        loader = lambda name: load_stt(args.data_dir, name)  # noqa: E731
+    server, port = make_server(engines, token, port=args.port, load_stt=loader)
     print(json.dumps({"ready": True, "port": port}), flush=True)
 
     # When the parent process goes away its end of our stdin closes: shut down instead of lingering.

package/dist/voice/friend_voice/models.py

@@ -46,6 +46,12 @@ def ensure_speaker_model(directory: Path, url: str = SPEAKER_URL, sha256: str =
     return target
 
 
+def load_stt(data_dir: Optional[str], name: str) -> WhisperSTT:
+    """One listening model, downloaded into the models folder when it is not there yet."""
+    root = Path(data_dir) if data_dir else Path.home() / ".friend" / "voice" / "models"
+    return WhisperSTT(name, str(root / "whisper"))
+
+
 def load_engines(data_dir: Optional[str], stt_model: str = "small", tts_voice: str = "en_US-lessac-medium") -> Engines:
     root = Path(data_dir) if data_dir else Path.home() / ".friend" / "voice" / "models"
     root.mkdir(parents=True, exist_ok=True)

package/dist/voice/friend_voice/server.py

@@ -4,20 +4,33 @@ from __future__ import annotations
 
 import hmac
 import json
+import re
+import threading
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from typing import Tuple
+from typing import Callable, Optional, Tuple
 from urllib.parse import parse_qs, urlparse
 
 from .engines import Engines
 from .tts import check_voice_name
 
 MAX_TTS_CHARS = 2000
+#: What a listening model is called: tiny, base, small, large-v3-turbo, or a Hugging Face folder such as Systran/faster-whisper-small.
+MODEL_NAME = re.compile(r"^[A-Za-z0-9_./-]{1,80}$")
 
 
 def make_server(
-    engines: Engines, token: str, port: int = 0, max_body: int = 4_000_000, io_timeout: float = 30
+    engines: Engines,
+    token: str,
+    port: int = 0,
+    max_body: int = 4_000_000,
+    io_timeout: float = 30,
+    load_stt: Optional[Callable[[str], object]] = None,
 ) -> Tuple[ThreadingHTTPServer, int]:
-    """Create (but do not start) a server bound to 127.0.0.1. Returns (server, actual_port)."""
+    """Create (but do not start) a server bound to 127.0.0.1. Returns (server, actual_port).
+
+    `load_stt(name)` builds (and, the first time, downloads) a listening model; POST /stt-model swaps it in while running.
+    """
+    swapping = threading.Lock()  # one model change at a time
 
     class Handler(BaseHTTPRequestHandler):
         protocol_version = "HTTP/1.1"
@@ -85,6 +98,8 @@ def make_server(
                 return self._tts()
             if url.path == "/embed":
                 return self._embed()
+            if url.path == "/stt-model":
+                return self._stt_model()
             self._drain(64 * 1024)
             self._json(404, {"error": "not found"}, close=True)
 
@@ -118,6 +133,26 @@ def make_server(
             except Exception as e:  # engine failures are reported, never crash the server
                 self._json(500, {"error": str(e)})
 
+        def _stt_model(self) -> None:
+            raw = self._read_body()
+            if raw is None:
+                return
+            if load_stt is None:
+                return self._json(501, {"error": "this speech engine cannot change its listening model"})
+            try:
+                name = json.loads(raw)["model"]
+            except (ValueError, KeyError, TypeError):
+                return self._json(400, {"error": "expected JSON with a model field"})
+            if not isinstance(name, str) or not MODEL_NAME.match(name) or ".." in name:
+                return self._json(400, {"error": "that is not a listening model name"})
+            with swapping:
+                try:
+                    fresh = load_stt(name)  # may take minutes the first time (download); the old model keeps listening meanwhile
+                except Exception as e:
+                    return self._json(500, {"error": str(e) or "the listening model could not be loaded"})
+                engines.stt = fresh
+            self._json(200, {"ok": True, "model": name})
+
         def _embed(self) -> None:
             audio = self._read_body()
             if audio is None: