dsh-live-voice 0.2.2 → 0.3.0

package/lib/server.js

@@ -1,249 +1,86 @@
-// src/engines/speaking/say.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import * as nodeFs from "node:fs/promises";
-import { constants } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-function failure(message, code, cause) {
-  return Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), { code });
-}
-function aborted(reason) {
-  return Object.assign(
-    new Error("Speech cancelled", reason === void 0 ? void 0 : { cause: reason }),
-    {
-      name: "AbortError",
-      code: "ABORT_ERR"
-    }
-  );
-}
-var SayEngine = class {
-  #spawn;
-  #fs;
-  #platform;
-  #tempRoot;
-  #killAfterMs;
-  #closeAfterMs;
-  #tail = Promise.resolve();
-  #requests = /* @__PURE__ */ new Set();
-  #active = null;
-  #unclosed = null;
-  #state = "idle";
-  #lastError = null;
-  constructor({
-    spawn = nodeSpawn,
-    fs = nodeFs,
-    platform = process.platform,
-    tempRoot = tmpdir(),
-    killAfterMs = 250,
-    closeAfterMs = 1e3
-  } = {}) {
-    for (const value of [killAfterMs, closeAfterMs]) {
-      if (!Number.isFinite(value) || value < 0 || value > 2147483647) {
-        throw new TypeError("Cancellation deadlines must be finite nonnegative milliseconds");
-      }
-    }
-    this.#spawn = spawn;
-    this.#fs = fs;
-    this.#platform = platform;
-    this.#tempRoot = tempRoot;
-    this.#killAfterMs = killAfterMs;
-    this.#closeAfterMs = closeAfterMs;
-  }
-  get state() {
-    return this.#state;
-  }
-  get lastError() {
-    return this.#lastError;
-  }
-  /** Checks the host executable, not browser support or installed voices. */
-  async getCapabilities() {
-    if (this.#platform !== "darwin") {
-      return { supported: false, pause: false, resume: false, reason: "unsupported-platform" };
-    }
-    try {
-      await this.#fs.access("/usr/bin/say", constants.X_OK);
-      return { supported: true, pause: true, resume: true, reason: null };
-    } catch {
-      return { supported: false, pause: false, resume: false, reason: "executable-unavailable" };
-    }
-  }
-  speak(text, { voice, rate, signal } = {}) {
-    if (typeof text !== "string") return Promise.reject(new TypeError("text must be a string"));
-    if (voice !== void 0 && (typeof voice !== "string" || !voice.trim() || voice.includes("\0"))) {
-      return Promise.reject(new TypeError("voice must be a nonempty string without NUL"));
-    }
-    if (rate !== void 0 && (!Number.isFinite(rate) || rate <= 0)) {
-      return Promise.reject(new TypeError("rate must be a positive finite number"));
-    }
-    if (signal !== void 0 && (signal === null || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function" || typeof signal.aborted !== "boolean")) {
-      return Promise.reject(new TypeError("signal must be an AbortSignal"));
-    }
-    for (const request2 of this.#requests) this.#cancel(request2);
-    const request = { cancelled: false, reason: void 0, cancelChild: null };
-    const onAbort = () => this.#cancel(request, signal.reason);
-    this.#requests.add(request);
-    signal?.addEventListener("abort", onAbort, { once: true });
-    if (signal?.aborted) onAbort();
-    const result = this.#tail.then(() => this.#run(request, text, voice, rate));
-    const settled = result.finally(() => {
-      signal?.removeEventListener("abort", onAbort);
-      this.#requests.delete(request);
-    });
-    this.#tail = settled.catch(() => {
-    });
-    return settled;
-  }
-  /** Resolves after queued requests and cleanup; rejects teardown failures. */
-  async stop() {
-    for (const request of this.#requests) this.#cancel(request);
-    const pending = this.#tail;
-    await pending;
-    if (this.#unclosed || this.#state === "error") throw this.#lastError;
-  }
-  pause() {
-    return this.#control("speaking", "paused", "SIGSTOP");
-  }
-  resume() {
-    return this.#control("paused", "speaking", "SIGCONT");
-  }
-  #control(from, to, signal) {
-    if (this.#platform !== "darwin" || this.#state !== from || !this.#active?.child || this.#active.cancelled)
-      return false;
-    try {
-      if (!this.#active.child.kill(signal))
-        throw failure("Unable to signal speech process", "SAY_SIGNAL_FAILED");
-      this.#state = to;
-      return true;
-    } catch (error) {
-      this.#lastError = error;
-      return false;
-    }
-  }
-  #cancel(request, reason) {
-    if (request.cancelled) return;
-    request.cancelled = true;
-    request.reason = reason;
-    request.cancelChild?.();
-  }
-  async #run(request, text, voice, rate) {
-    let directory;
-    let error;
-    const check = () => {
-      if (request.cancelled) throw aborted(request.reason);
-    };
-    try {
-      check();
-      if (this.#unclosed)
-        throw failure("Previous speech process has not closed", "SAY_PROCESS_UNCLOSED");
-      this.#active = request;
-      this.#state = "preparing";
-      this.#lastError = null;
-      const capability = await this.getCapabilities();
-      check();
-      if (!capability.supported) throw failure("macOS say is unavailable", "SAY_UNAVAILABLE");
-      directory = await this.#fs.mkdtemp(join(this.#tempRoot, "dsh-live-voice-say-"));
-      check();
-      await this.#fs.chmod(directory, 448);
-      const file = join(directory, "speech.txt");
-      await this.#fs.writeFile(file, text, { encoding: "utf8", mode: 384, flag: "wx" });
-      await this.#fs.chmod(file, 384);
-      check();
-      const args = ["-f", file];
-      if (voice !== void 0) args.push("-v", voice);
-      if (rate !== void 0) args.push("-r", String(rate));
-      const child = this.#spawn("/usr/bin/say", args, { shell: false, stdio: "ignore" });
-      request.child = child;
-      this.#state = "speaking";
-      await this.#waitForClose(request, child);
-      check();
-    } catch (caught) {
-      error = caught;
-    } finally {
-      request.cancelChild = null;
-      if (directory) {
-        try {
-          await this.#fs.rm(directory, { recursive: true, force: true });
-        } catch (cleanupError) {
-          error = failure(
-            "Speech temporary-file cleanup failed",
-            "SAY_CLEANUP_FAILED",
-            error ? new AggregateError([error, cleanupError]) : cleanupError
-          );
-        }
-      }
-      if (!error && request.cancelled) error = aborted(request.reason);
-      if (this.#active === request) this.#active = null;
-      if (error && error.name !== "AbortError") {
-        this.#state = "error";
-        this.#lastError = error;
-      } else if (!this.#unclosed && this.#state !== "error") this.#state = "idle";
-    }
-    if (error) throw error;
-  }
-  #waitForClose(request, child) {
-    return new Promise((resolve, reject) => {
-      let closed = false;
-      let processError;
-      let killTimer;
-      let closeTimer;
-      const send = (signal) => {
-        try {
-          if (!child.kill(signal))
-            processError ??= failure("Unable to signal speech process", "SAY_SIGNAL_FAILED");
-        } catch (error) {
-          processError ??= error;
-        }
-      };
-      const onError = (error) => {
-        processError ??= error;
-      };
-      child.on("error", onError);
-      child.once("close", (code, signal) => {
-        closed = true;
-        clearTimeout(killTimer);
-        clearTimeout(closeTimer);
-        child.removeListener("error", onError);
-        if (this.#unclosed === child) this.#unclosed = null;
-        if (request.cancelled) reject(aborted(request.reason));
-        else if (processError) reject(processError);
-        else if (code !== 0)
-          reject(
-            failure("Speech process exited unsuccessfully", "SAY_EXIT_FAILED", { code, signal })
-          );
-        else resolve();
-      });
-      request.cancelChild = () => {
-        if (closed) return;
-        const paused = this.#state === "paused";
-        this.#state = "stopping";
-        if (paused) send("SIGCONT");
-        send("SIGTERM");
-        if (closed) return;
-        killTimer = setTimeout(() => {
-          send("SIGKILL");
-          if (closed) return;
-          closeTimer = setTimeout(() => {
-            if (closed) return;
-            this.#unclosed = child;
-            reject(
-              failure(
-                "Speech process did not close after cancellation",
-                "SAY_STOP_TIMEOUT",
-                processError
-              )
-            );
-          }, this.#closeAfterMs);
-        }, this.#killAfterMs);
-      };
-      if (request.cancelled) request.cancelChild();
-    });
-  }
-};
+// src/modules/core/qwen/QwenHttpHost.ts
+import { readFile as readFile2, mkdir as mkdir2, writeFile as writeFile2, rename as rename2, rm as rm2 } from "node:fs/promises";
+import { homedir as homedir2 } from "node:os";
+import { dirname as dirname2, join as join2 } from "node:path";
+import { randomUUID as randomUUID2 } from "node:crypto";
 
-// src/engines/recognition/whisper-http-host.ts
+// src/modules/core/settings.ts
+var voiceDetectionPresets = Object.freeze({
+  short: Object.freeze({
+    silenceMs: 900,
+    label: "Short",
+    description: "Send quickly after a short pause."
+  }),
+  natural: Object.freeze({
+    silenceMs: 1500,
+    label: "Natural",
+    description: "Allow normal pauses between phrases."
+  }),
+  long: Object.freeze({
+    silenceMs: 2200,
+    label: "Long",
+    description: "Wait through longer thinking pauses."
+  })
+});
+var qwenVoices = Object.freeze([
+  Object.freeze({ value: "aiden", label: "Aiden \u2014 male, American English" }),
+  Object.freeze({ value: "ryan", label: "Ryan \u2014 male, English" }),
+  Object.freeze({ value: "uncle_fu", label: "Uncle Fu \u2014 male, Chinese" }),
+  Object.freeze({ value: "dylan", label: "Dylan \u2014 male, Beijing Chinese" }),
+  Object.freeze({ value: "eric", label: "Eric \u2014 male, Sichuan Chinese" }),
+  Object.freeze({ value: "vivian", label: "Vivian \u2014 female, Chinese" }),
+  Object.freeze({ value: "serena", label: "Serena \u2014 female, Chinese" }),
+  Object.freeze({ value: "ono_anna", label: "Ono Anna \u2014 female, Japanese" }),
+  Object.freeze({ value: "sohee", label: "Sohee \u2014 female, Korean" })
+]);
+var defaultQwenVoice = qwenVoices[0].value;
+var isQwenVoice = (value) => qwenVoices.some((voice) => voice.value === value);
+var defaultAgentVoiceContext = `Live Voice output is active. Your entire user-facing response will be spoken aloud.
+Be concise and conversational. Lead with the answer or next action. Avoid unnecessary repetition, long preambles, dense lists, raw code, paths, and verbose status narration.
+Do not narrate routine tool activity by default. If the user explicitly asks you to keep them informed while working, provide brief spoken progress updates only at meaningful milestones.`;
+var defaultSettings = Object.freeze({
+  engine: "browser",
+  recognitionEngine: "browser",
+  recognitionProcessLocally: true,
+  recognitionAutoInstall: true,
+  voiceDetectionPreset: "natural",
+  recognitionMaxUtteranceSeconds: 60,
+  microphoneEnabled: true,
+  holdToTalkEnabled: true,
+  announceAssistantMessages: true,
+  agentVoiceContextEnabled: true,
+  agentVoiceContext: defaultAgentVoiceContext,
+  interruptSpeechOnUserMessage: false,
+  sendingMode: "manual",
+  autoSendDelaySeconds: 4,
+  assistantSpeechDelaySeconds: 3,
+  mode: "speaker",
+  lang: "pt-BR",
+  recognitionLang: "pt-BR",
+  voice: "",
+  inputDeviceId: "",
+  outputDeviceId: "",
+  recognitionFilterEnabled: true,
+  recognitionMinimumWords: 2,
+  voiceCommandsEnabled: true,
+  voiceCommandSend: "send, send message",
+  voiceCommandQueue: "queue, queue message",
+  voiceCommandEnd: "end, end conversation",
+  voiceCommandMute: "mute, stop listening",
+  voiceCommandResume: "resume, start listening",
+  voiceCommandStopSpeaking: "stop talking, stop speaking, shut up",
+  voiceCommandClear: "clear all, clear message",
+  outputCodeFilterEnabled: true,
+  outputCodeMaxLines: 5,
+  outputCodeNotice: "Look the code on out conversation",
+  rate: 1,
+  segmentGapMs: 400
+});
+
+// src/modules/recognition/engines/whisper/whisperRecognitionHost.ts
 import { readFile, mkdir, writeFile, rename, rm } from "node:fs/promises";
 import { homedir } from "node:os";
-import { dirname, join as join2 } from "node:path";
+import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
 var LOOPBACK = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1", "[::1]"]);
 function validateWhisperConfig(value) {
@@ -257,7 +94,7 @@ function validateWhisperConfig(value) {
     throw new Error("Request timeout must be an integer between 100 and 300000 ms.");
   return { url: url.href, healthUrl: health, timeoutMs: value.timeoutMs };
 }
-function createWhisperConfigStore(path = join2(homedir(), ".dsh", "dsh-live-voice-whisper.json")) {
+function createWhisperConfigStore(path = join(homedir(), ".dsh", "dsh-live-voice-whisper.json")) {
   return {
     async load() {
       try {
@@ -378,119 +215,46 @@ var WhisperHttpHost = class {
     try {
       const config = configuration ? validateWhisperConfig(configuration) : await this.getConfig();
       const response = await this.request(
-        new URL(config.healthUrl, config.url),
-        { signal },
-        config
-      );
-      return response.ok ? { supported: true, local: true, streaming: false, maxBytes: this.maxBytes } : {
-        supported: false,
-        local: true,
-        streaming: false,
-        reason: "Whisper HTTP health check failed (" + response.status + ")."
-      };
-    } catch (error) {
-      return {
-        supported: false,
-        local: true,
-        streaming: false,
-        reason: "Whisper HTTP server is unreachable: " + (error?.message || error)
-      };
-    }
-  }
-  async transcribe(input, { lang = "auto", signal } = {}) {
-    const bytes = validateMonoPcm16Wav(input, { maxBytes: this.maxBytes }), form = new FormData();
-    form.append("file", new Blob([bytes], { type: "audio/wav" }), "utterance.wav");
-    form.append("response_format", "json");
-    form.append("language", lang.startsWith("pt") ? "pt" : lang.startsWith("en") ? "en" : "auto");
-    const config = await this.getConfig();
-    return this.request(
-      new URL(config.url),
-      { method: "POST", body: form, signal },
-      config,
-      async (response) => {
-        if (!response.ok)
-          throw new Error("Whisper HTTP transcription failed (" + response.status + ").");
-        const json = await response.json();
-        return { text: clean(json?.text) };
-      }
-    );
-  }
-};
-
-// src/engines/qwen-http-host.ts
-import { readFile as readFile2, mkdir as mkdir2, writeFile as writeFile2, rename as rename2, rm as rm2 } from "node:fs/promises";
-import { homedir as homedir2 } from "node:os";
-import { dirname as dirname2, join as join3 } from "node:path";
-import { randomUUID as randomUUID2 } from "node:crypto";
-
-// src/core/settings.ts
-var voiceDetectionPresets = Object.freeze({
-  short: Object.freeze({
-    silenceMs: 900,
-    label: "Short",
-    description: "Send quickly after a short pause."
-  }),
-  natural: Object.freeze({
-    silenceMs: 1500,
-    label: "Natural",
-    description: "Allow normal pauses between phrases."
-  }),
-  long: Object.freeze({
-    silenceMs: 2200,
-    label: "Long",
-    description: "Wait through longer thinking pauses."
-  })
-});
-var qwenVoices = Object.freeze([
-  Object.freeze({ value: "aiden", label: "Aiden \u2014 male, American English" }),
-  Object.freeze({ value: "ryan", label: "Ryan \u2014 male, English" }),
-  Object.freeze({ value: "uncle_fu", label: "Uncle Fu \u2014 male, Chinese" }),
-  Object.freeze({ value: "dylan", label: "Dylan \u2014 male, Beijing Chinese" }),
-  Object.freeze({ value: "eric", label: "Eric \u2014 male, Sichuan Chinese" }),
-  Object.freeze({ value: "vivian", label: "Vivian \u2014 female, Chinese" }),
-  Object.freeze({ value: "serena", label: "Serena \u2014 female, Chinese" }),
-  Object.freeze({ value: "ono_anna", label: "Ono Anna \u2014 female, Japanese" }),
-  Object.freeze({ value: "sohee", label: "Sohee \u2014 female, Korean" })
-]);
-var defaultQwenVoice = qwenVoices[0].value;
-var isQwenVoice = (value) => qwenVoices.some((voice) => voice.value === value);
-var defaultSettings = Object.freeze({
-  engine: "browser",
-  recognitionEngine: "browser",
-  recognitionProcessLocally: true,
-  recognitionAutoInstall: true,
-  voiceDetectionPreset: "natural",
-  recognitionMaxUtteranceSeconds: 60,
-  microphoneEnabled: true,
-  holdToTalkEnabled: true,
-  announceAssistantMessages: true,
-  interruptSpeechOnUserMessage: false,
-  sendingMode: "manual",
-  autoSendDelaySeconds: 4,
-  assistantSpeechDelaySeconds: 3,
-  mode: "speaker",
-  lang: "pt-BR",
-  recognitionLang: "pt-BR",
-  voice: "",
-  inputDeviceId: "",
-  outputDeviceId: "",
-  recognitionFilterEnabled: true,
-  recognitionMinimumWords: 2,
-  voiceCommandsEnabled: true,
-  voiceCommandSend: "send, send message",
-  voiceCommandQueue: "queue, queue message",
-  voiceCommandEnd: "end, end conversation",
-  voiceCommandMute: "mute, stop listening",
-  voiceCommandResume: "resume, start listening",
-  voiceCommandStopSpeaking: "stop talking, stop speaking, shut up",
-  voiceCommandClear: "clear all, clear message",
-  outputCodeFilterEnabled: true,
-  outputCodeMaxLines: 5,
-  outputCodeNotice: "Look the code on out conversation",
-  rate: 1
-});
+        new URL(config.healthUrl, config.url),
+        { signal },
+        config
+      );
+      return response.ok ? { supported: true, local: true, streaming: false, maxBytes: this.maxBytes } : {
+        supported: false,
+        local: true,
+        streaming: false,
+        reason: "Whisper HTTP health check failed (" + response.status + ")."
+      };
+    } catch (error) {
+      return {
+        supported: false,
+        local: true,
+        streaming: false,
+        reason: "Whisper HTTP server is unreachable: " + (error?.message || error)
+      };
+    }
+  }
+  async transcribe(input, { lang = "auto", signal } = {}) {
+    const bytes = validateMonoPcm16Wav(input, { maxBytes: this.maxBytes }), form = new FormData();
+    form.append("file", new Blob([bytes], { type: "audio/wav" }), "utterance.wav");
+    form.append("response_format", "json");
+    form.append("language", lang.startsWith("pt") ? "pt" : lang.startsWith("en") ? "en" : "auto");
+    const config = await this.getConfig();
+    return this.request(
+      new URL(config.url),
+      { method: "POST", body: form, signal },
+      config,
+      async (response) => {
+        if (!response.ok)
+          throw new Error("Whisper HTTP transcription failed (" + response.status + ").");
+        const json = await response.json();
+        return { text: clean(json?.text) };
+      }
+    );
+  }
+};
 
-// src/engines/qwen-http-host.ts
+// src/modules/core/qwen/QwenHttpHost.ts
 var clean2 = (value) => String(value ?? "").trim();
 function resolveQwenBaseUrl(value = process.env.DSH_LIVE_VOICE_QWEN_URL || "http://127.0.0.1:8080/") {
   const url = new URL(value);
@@ -509,7 +273,7 @@ function validateQwenConfig(value) {
     throw new Error("Request timeout must be an integer between 1000 and 600000 ms.");
   return { baseUrl: baseUrl.href, timeoutMs: value.timeoutMs };
 }
-function createQwenConfigStore(path = join3(homedir2(), ".dsh", "dsh-live-voice-qwen.json")) {
+function createQwenConfigStore(path = join2(homedir2(), ".dsh", "dsh-live-voice-qwen.json")) {
   return {
     async load() {
       try {
@@ -606,109 +370,440 @@ var QwenHttpHost = class {
     }));
     return { ...response, ominix: response.body?.service === "ominix-api" };
   }
-  async capability(signal, configuration, kind = "both") {
+  async capability(signal, configuration, kind = "both") {
+    try {
+      const config = configuration ? validateQwenConfig(configuration) : await this.getConfig();
+      const health = await this.serverInfo(signal, config);
+      let models = health.body?.models;
+      if (health.ominix && health.ok) {
+        const status = await this.request(
+          "v1/models/status",
+          { signal },
+          config,
+          async (response) => ({
+            ok: response.ok,
+            status: response.status,
+            body: response.ok ? await response.json() : null
+          })
+        );
+        models = {
+          asr: status.body?.models?.asr === "qwen3-asr",
+          tts: status.body?.models?.qwen3_tts === "customvoice"
+        };
+      }
+      const ready = kind === "asr" ? models?.asr === true : kind === "tts" ? models?.tts === true : models?.asr === true && models?.tts === true;
+      return health.ok && ready ? { supported: true, local: true, location: "host", streaming: false, models } : {
+        supported: false,
+        local: true,
+        location: "host",
+        streaming: false,
+        reason: `Qwen health check did not report ${kind === "both" ? "both ASR and TTS" : kind.toUpperCase()} ready (${health.status}).`
+      };
+    } catch (error) {
+      return {
+        supported: false,
+        local: true,
+        location: "host",
+        streaming: false,
+        reason: "Qwen speech server is unreachable: " + (error?.message || error)
+      };
+    }
+  }
+  async transcribe(input, { lang = "pt-BR", signal } = {}) {
+    const bytes = validateMonoPcm16Wav(input, { maxBytes: this.maxBytes }), resolved = language(lang), health = await this.serverInfo(signal);
+    let body, headers;
+    if (health.ominix) {
+      headers = { "content-type": "application/json" };
+      body = JSON.stringify({
+        file: Buffer.from(bytes).toString("base64"),
+        language: resolved,
+        response_format: "json"
+      });
+    } else {
+      const form = new FormData();
+      form.append("file", new Blob([bytes], { type: "audio/wav" }), "utterance.wav");
+      form.append("response_format", "json");
+      if (resolved) form.append("language", resolved);
+      body = form;
+    }
+    return this.request(
+      "v1/audio/transcriptions",
+      { method: "POST", headers, body, signal },
+      void 0,
+      async (response) => {
+        if (!response.ok) throw new Error("Qwen transcription failed (" + response.status + ").");
+        const json = await response.json();
+        return { text: clean2(json?.text) };
+      }
+    );
+  }
+  async synthesize(text, { lang = "pt-BR", signal, voice = defaultQwenVoice } = {}) {
+    if (typeof text !== "string" || !text.trim() || text.length > 1e5 || text.includes("\0"))
+      throw new Error("Speech text must contain 1\u2013100000 characters without NUL.");
+    if (!isQwenVoice(voice)) throw new Error("Unsupported Qwen voice.");
+    return this.request(
+      "v1/audio/speech",
+      {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({
+          model: "qwen3-tts",
+          input: text,
+          voice,
+          language: language(lang) || "portuguese",
+          response_format: "wav"
+        }),
+        signal
+      },
+      void 0,
+      async (response) => {
+        if (!response.ok) throw new Error("Qwen synthesis failed (" + response.status + ").");
+        const length = Number(response.headers.get("content-length") || 0);
+        if (length > this.maxSpeechBytes) throw new Error("Qwen speech response is too large.");
+        const bytes = await response.arrayBuffer();
+        if (bytes.byteLength < 44 || bytes.byteLength > this.maxSpeechBytes)
+          throw new Error("Qwen returned invalid or oversized speech audio.");
+        return bytes;
+      }
+    );
+  }
+};
+
+// src/modules/speak/engines/audio/M4aAacTranscoder.ts
+import { execFile as nodeExecFile } from "node:child_process";
+import * as nodeFs from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join as join3 } from "node:path";
+import { promisify } from "node:util";
+var execFile = promisify(nodeExecFile);
+var aborted = (reason) => Object.assign(new Error("Speech audio conversion was cancelled."), {
+  name: "AbortError",
+  cause: reason
+});
+async function wavToM4aAac(input, { fs = nodeFs, run = execFile, tempRoot = tmpdir(), signal, bitrate = 64e3 } = {}) {
+  if (!input || !Number.isSafeInteger(input.byteLength) || input.byteLength < 44)
+    throw new TypeError("A valid WAV audio buffer is required.");
+  if (!Number.isFinite(bitrate) || bitrate < 16e3 || bitrate > 256e3)
+    throw new TypeError("AAC bitrate must be between 16000 and 256000 bps.");
+  if (signal?.aborted) throw aborted(signal.reason);
+  let directory, result, error;
+  try {
+    directory = await fs.mkdtemp(join3(tempRoot, "dsh-live-voice-aac-"));
+    await fs.chmod(directory, 448);
+    const source = join3(directory, "speech.wav"), target = join3(directory, "speech.m4a");
+    await fs.writeFile(source, input, { mode: 384, flag: "wx" });
+    if (signal?.aborted) throw aborted(signal.reason);
+    await run(
+      "/usr/bin/afconvert",
+      ["-f", "m4af", "-d", "aac", "-b", String(bitrate), source, target],
+      {
+        shell: false,
+        signal
+      }
+    );
+    if (signal?.aborted) throw aborted(signal.reason);
+    result = await fs.readFile(target);
+    if (result.byteLength < 16 || Buffer.from(result).subarray(4, 8).toString("ascii") !== "ftyp")
+      throw new Error("Audio conversion produced invalid M4A output.");
+  } catch (caught) {
+    error = signal?.aborted && caught?.name !== "AbortError" ? aborted(signal.reason) : caught;
+  } finally {
+    if (directory) {
+      try {
+        await fs.rm(directory, { recursive: true, force: true });
+      } catch (cleanupError) {
+        error ||= cleanupError;
+      }
+    }
+  }
+  if (error) throw error;
+  return result;
+}
+
+// src/modules/speak/engines/say/SaySpeakingEngine.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import * as nodeFs2 from "node:fs/promises";
+import { constants } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join4 } from "node:path";
+function failure(message, code, cause) {
+  return Object.assign(new Error(message, cause === void 0 ? void 0 : { cause }), { code });
+}
+function aborted2(reason) {
+  return Object.assign(
+    new Error("Speech cancelled", reason === void 0 ? void 0 : { cause: reason }),
+    {
+      name: "AbortError",
+      code: "ABORT_ERR"
+    }
+  );
+}
+var SayEngine = class {
+  #spawn;
+  #fs;
+  #platform;
+  #tempRoot;
+  #killAfterMs;
+  #closeAfterMs;
+  #tail = Promise.resolve();
+  #requests = /* @__PURE__ */ new Set();
+  #active = null;
+  #unclosed = null;
+  #state = "idle";
+  #lastError = null;
+  constructor({
+    spawn = nodeSpawn,
+    fs = nodeFs2,
+    platform = process.platform,
+    tempRoot = tmpdir2(),
+    killAfterMs = 250,
+    closeAfterMs = 1e3
+  } = {}) {
+    for (const value of [killAfterMs, closeAfterMs]) {
+      if (!Number.isFinite(value) || value < 0 || value > 2147483647) {
+        throw new TypeError("Cancellation deadlines must be finite nonnegative milliseconds");
+      }
+    }
+    this.#spawn = spawn;
+    this.#fs = fs;
+    this.#platform = platform;
+    this.#tempRoot = tempRoot;
+    this.#killAfterMs = killAfterMs;
+    this.#closeAfterMs = closeAfterMs;
+  }
+  get state() {
+    return this.#state;
+  }
+  get lastError() {
+    return this.#lastError;
+  }
+  /** Checks the host executable, not browser support or installed voices. */
+  async getCapabilities() {
+    if (this.#platform !== "darwin") {
+      return {
+        supported: false,
+        pause: false,
+        resume: false,
+        audioFormat: "audio/wav",
+        reason: "unsupported-platform"
+      };
+    }
+    try {
+      await this.#fs.access("/usr/bin/say", constants.X_OK);
+      return {
+        supported: true,
+        pause: false,
+        resume: false,
+        audioFormat: "audio/wav",
+        reason: null
+      };
+    } catch {
+      return {
+        supported: false,
+        pause: false,
+        resume: false,
+        audioFormat: "audio/wav",
+        reason: "executable-unavailable"
+      };
+    }
+  }
+  speak(text, { voice, rate, signal } = {}) {
+    if (typeof text !== "string") return Promise.reject(new TypeError("text must be a string"));
+    if (voice !== void 0 && (typeof voice !== "string" || !voice.trim() || voice.includes("\0"))) {
+      return Promise.reject(new TypeError("voice must be a nonempty string without NUL"));
+    }
+    if (rate !== void 0 && (!Number.isFinite(rate) || rate <= 0)) {
+      return Promise.reject(new TypeError("rate must be a positive finite number"));
+    }
+    if (signal !== void 0 && (signal === null || typeof signal.addEventListener !== "function" || typeof signal.removeEventListener !== "function" || typeof signal.aborted !== "boolean")) {
+      return Promise.reject(new TypeError("signal must be an AbortSignal"));
+    }
+    for (const request2 of this.#requests) this.#cancel(request2);
+    const request = { cancelled: false, reason: void 0, cancelChild: null };
+    const onAbort = () => this.#cancel(request, signal.reason);
+    this.#requests.add(request);
+    signal?.addEventListener("abort", onAbort, { once: true });
+    if (signal?.aborted) onAbort();
+    const result = this.#tail.then(() => this.#run(request, text, voice, rate));
+    const settled = result.finally(() => {
+      signal?.removeEventListener("abort", onAbort);
+      this.#requests.delete(request);
+    });
+    this.#tail = settled.catch(() => {
+    });
+    return settled;
+  }
+  /** Resolves after queued requests and cleanup; rejects teardown failures. */
+  async stop() {
+    for (const request of this.#requests) this.#cancel(request);
+    const pending = this.#tail;
+    await pending;
+    if (this.#unclosed || this.#state === "error") throw this.#lastError;
+  }
+  pause() {
+    return this.#control("speaking", "paused", "SIGSTOP");
+  }
+  resume() {
+    return this.#control("paused", "speaking", "SIGCONT");
+  }
+  #control(from, to, signal) {
+    if (this.#platform !== "darwin" || this.#state !== from || !this.#active?.child || this.#active.cancelled)
+      return false;
     try {
-      const config = configuration ? validateQwenConfig(configuration) : await this.getConfig();
-      const health = await this.serverInfo(signal, config);
-      let models = health.body?.models;
-      if (health.ominix && health.ok) {
-        const status = await this.request(
-          "v1/models/status",
-          { signal },
-          config,
-          async (response) => ({
-            ok: response.ok,
-            status: response.status,
-            body: response.ok ? await response.json() : null
-          })
-        );
-        models = {
-          asr: status.body?.models?.asr === "qwen3-asr",
-          tts: status.body?.models?.qwen3_tts === "customvoice"
-        };
-      }
-      const ready = kind === "asr" ? models?.asr === true : kind === "tts" ? models?.tts === true : models?.asr === true && models?.tts === true;
-      return health.ok && ready ? { supported: true, local: true, location: "host", streaming: false, models } : {
-        supported: false,
-        local: true,
-        location: "host",
-        streaming: false,
-        reason: `Qwen health check did not report ${kind === "both" ? "both ASR and TTS" : kind.toUpperCase()} ready (${health.status}).`
-      };
+      if (!this.#active.child.kill(signal))
+        throw failure("Unable to signal speech process", "SAY_SIGNAL_FAILED");
+      this.#state = to;
+      return true;
     } catch (error) {
-      return {
-        supported: false,
-        local: true,
-        location: "host",
-        streaming: false,
-        reason: "Qwen speech server is unreachable: " + (error?.message || error)
-      };
+      this.#lastError = error;
+      return false;
     }
   }
-  async transcribe(input, { lang = "pt-BR", signal } = {}) {
-    const bytes = validateMonoPcm16Wav(input, { maxBytes: this.maxBytes }), resolved = language(lang), health = await this.serverInfo(signal);
-    let body, headers;
-    if (health.ominix) {
-      headers = { "content-type": "application/json" };
-      body = JSON.stringify({
-        file: Buffer.from(bytes).toString("base64"),
-        language: resolved,
-        response_format: "json"
-      });
-    } else {
-      const form = new FormData();
-      form.append("file", new Blob([bytes], { type: "audio/wav" }), "utterance.wav");
-      form.append("response_format", "json");
-      if (resolved) form.append("language", resolved);
-      body = form;
-    }
-    return this.request(
-      "v1/audio/transcriptions",
-      { method: "POST", headers, body, signal },
-      void 0,
-      async (response) => {
-        if (!response.ok) throw new Error("Qwen transcription failed (" + response.status + ").");
-        const json = await response.json();
-        return { text: clean2(json?.text) };
-      }
-    );
+  #cancel(request, reason) {
+    if (request.cancelled) return;
+    request.cancelled = true;
+    request.reason = reason;
+    request.cancelChild?.();
   }
-  async synthesize(text, { lang = "pt-BR", signal, voice = defaultQwenVoice } = {}) {
-    if (typeof text !== "string" || !text.trim() || text.length > 1e5 || text.includes("\0"))
-      throw new Error("Speech text must contain 1\u2013100000 characters without NUL.");
-    if (!isQwenVoice(voice)) throw new Error("Unsupported Qwen voice.");
-    return this.request(
-      "v1/audio/speech",
-      {
-        method: "POST",
-        headers: { "content-type": "application/json" },
-        body: JSON.stringify({
-          model: "qwen3-tts",
-          input: text,
-          voice,
-          language: language(lang) || "portuguese",
-          response_format: "wav"
-        }),
-        signal
-      },
-      void 0,
-      async (response) => {
-        if (!response.ok) throw new Error("Qwen synthesis failed (" + response.status + ").");
-        const length = Number(response.headers.get("content-length") || 0);
-        if (length > this.maxSpeechBytes) throw new Error("Qwen speech response is too large.");
-        const bytes = await response.arrayBuffer();
-        if (bytes.byteLength < 44 || bytes.byteLength > this.maxSpeechBytes)
-          throw new Error("Qwen returned invalid or oversized speech audio.");
-        return bytes;
+  async #run(request, text, voice, rate) {
+    let directory;
+    let error;
+    let result;
+    const check = () => {
+      if (request.cancelled) throw aborted2(request.reason);
+    };
+    try {
+      check();
+      if (this.#unclosed)
+        throw failure("Previous speech process has not closed", "SAY_PROCESS_UNCLOSED");
+      this.#active = request;
+      this.#state = "preparing";
+      this.#lastError = null;
+      const capability = await this.getCapabilities();
+      check();
+      if (!capability.supported) throw failure("macOS say is unavailable", "SAY_UNAVAILABLE");
+      directory = await this.#fs.mkdtemp(join4(this.#tempRoot, "dsh-live-voice-say-"));
+      check();
+      await this.#fs.chmod(directory, 448);
+      const file = join4(directory, "speech.txt");
+      const output = join4(directory, "speech.wav");
+      await this.#fs.writeFile(file, text, { encoding: "utf8", mode: 384, flag: "wx" });
+      await this.#fs.chmod(file, 384);
+      check();
+      const args = ["-f", file, "-o", output, "--file-format=WAVE", "--data-format=LEI16@22050"];
+      if (voice !== void 0) args.push("-v", voice);
+      if (rate !== void 0) args.push("-r", String(rate));
+      const child = this.#spawn("/usr/bin/say", args, { shell: false, stdio: "ignore" });
+      request.child = child;
+      this.#state = "speaking";
+      await this.#waitForClose(request, child);
+      check();
+      result = await this.#fs.readFile(output);
+    } catch (caught) {
+      error = caught;
+    } finally {
+      request.cancelChild = null;
+      if (directory) {
+        try {
+          await this.#fs.rm(directory, { recursive: true, force: true });
+        } catch (cleanupError) {
+          error = failure(
+            "Speech temporary-file cleanup failed",
+            "SAY_CLEANUP_FAILED",
+            error ? new AggregateError([error, cleanupError]) : cleanupError
+          );
+        }
       }
-    );
+      if (!error && request.cancelled) error = aborted2(request.reason);
+      if (this.#active === request) this.#active = null;
+      if (error && error.name !== "AbortError") {
+        this.#state = "error";
+        this.#lastError = error;
+      } else if (!this.#unclosed && this.#state !== "error") this.#state = "idle";
+    }
+    if (error) throw error;
+    return result;
+  }
+  #waitForClose(request, child) {
+    return new Promise((resolve, reject) => {
+      let closed = false;
+      let processError;
+      let killTimer;
+      let closeTimer;
+      const send = (signal) => {
+        try {
+          if (!child.kill(signal))
+            processError ??= failure("Unable to signal speech process", "SAY_SIGNAL_FAILED");
+        } catch (error) {
+          processError ??= error;
+        }
+      };
+      const onError = (error) => {
+        processError ??= error;
+      };
+      child.on("error", onError);
+      child.once("close", (code, signal) => {
+        closed = true;
+        clearTimeout(killTimer);
+        clearTimeout(closeTimer);
+        child.removeListener("error", onError);
+        if (this.#unclosed === child) this.#unclosed = null;
+        if (request.cancelled) reject(aborted2(request.reason));
+        else if (processError) reject(processError);
+        else if (code !== 0)
+          reject(
+            failure("Speech process exited unsuccessfully", "SAY_EXIT_FAILED", { code, signal })
+          );
+        else resolve();
+      });
+      request.cancelChild = () => {
+        if (closed) return;
+        const paused = this.#state === "paused";
+        this.#state = "stopping";
+        if (paused) send("SIGCONT");
+        send("SIGTERM");
+        if (closed) return;
+        killTimer = setTimeout(() => {
+          send("SIGKILL");
+          if (closed) return;
+          closeTimer = setTimeout(() => {
+            if (closed) return;
+            this.#unclosed = child;
+            reject(
+              failure(
+                "Speech process did not close after cancellation",
+                "SAY_STOP_TIMEOUT",
+                processError
+              )
+            );
+          }, this.#closeAfterMs);
+        }, this.#killAfterMs);
+      };
+      if (request.cancelled) request.cancelChild();
+    });
   }
 };
 
-// src/server.ts
+// src/app/server/apply.ts
 var name = "dsh-live-voice";
-var inject = ["connection"];
+var inject = ["connection", "systemPrompt"];
 var SAY_CHANNEL = "/api/dsh-live-voice";
+var VOICE_CONTEXT_PATH = SAY_CHANNEL + "/voice-context";
+function createVoiceContextStore() {
+  const entries = /* @__PURE__ */ new Map();
+  return {
+    get(sessionId) {
+      return entries.get(sessionId) || "";
+    },
+    set(sessionId, text) {
+      if (text) entries.set(sessionId, text);
+      else entries.delete(sessionId);
+    },
+    clear() {
+      entries.clear();
+    }
+  };
+}
 var ok = (value) => ({ ok: true, value });
 var fail = (code, message) => ({ ok: false, error: { code, message, details: {} } });
 var identity = (value) => typeof value === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(value);
@@ -782,15 +877,105 @@ function createSayHost({ engine = new SayEngine() } = {}) {
     await engine.stop();
     active = null;
   }
-  return { handle, dispose };
+  return { handle, dispose, engine };
 }
 function apply(ctx, {
   whisperStore = createWhisperConfigStore(),
   whisperFetch = globalThis.fetch,
   qwenStore = createQwenConfigStore(),
-  qwenFetch = globalThis.fetch
+  qwenFetch = globalThis.fetch,
+  voiceContextStore = createVoiceContextStore(),
+  createSayEngine = () => new SayEngine(),
+  encodeHostSpeech = wavToM4aAac
 } = {}) {
+  ctx.systemPrompt.variable(
+    "live_voice_context",
+    (assemblyContext) => voiceContextStore.get(String(assemblyContext.agent?.sessionId || ""))
+  );
+  ctx.systemPrompt.context({
+    name: "dsh-live-voice:spoken-output",
+    order: 700,
+    text: "{{live_voice_context}}"
+  });
+  const disposeVoiceContext = ctx.connection.fetch.register({
+    path: VOICE_CONTEXT_PATH,
+    methods: ["PUT"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      try {
+        const body = await request.json();
+        if (!identity(body?.sessionId) || typeof body?.context !== "string" || body.context.length > 4e3 || body.context.includes("\0"))
+          return Response.json(
+            fail("invalid-request", "A valid session ID and voice context are required."),
+            { status: 400 }
+          );
+        voiceContextStore.set(body.sessionId, body.active === true ? body.context.trim() : "");
+        return Response.json(ok({ active: body.active === true && Boolean(body.context.trim()) }));
+      } catch {
+        return Response.json(fail("invalid-request", "Invalid voice context request."), {
+          status: 400
+        });
+      }
+    }
+  });
+  ctx.effect(
+    () => () => {
+      disposeVoiceContext();
+      voiceContextStore.clear();
+    },
+    "dsh-live-voice: remove voice context"
+  );
   const host = createSayHost();
+  const saySyntheses = /* @__PURE__ */ new Set();
+  const sayCapability = ctx.connection.fetch.register({
+    path: SAY_CHANNEL + "/say/capabilities",
+    methods: ["GET"],
+    requestBody: "buffered",
+    fetch: async () => Response.json(ok({ ...await host.engine.getCapabilities(), audioFormat: "audio/mp4" }))
+  });
+  const saySpeech = ctx.connection.fetch.register({
+    path: SAY_CHANNEL + "/say/speech",
+    methods: ["POST"],
+    requestBody: "buffered",
+    fetch: async (request) => {
+      try {
+        const body = await request.json();
+        const engine = createSayEngine();
+        saySyntheses.add(engine);
+        try {
+          const wav = await engine.speak(body?.text, {
+            voice: body?.voice,
+            rate: body?.rate,
+            signal: request.signal
+          });
+          const bytes = await encodeHostSpeech(wav, { signal: request.signal });
+          return new Response(bytes, {
+            status: 200,
+            headers: { "content-type": "audio/mp4", "cache-control": "no-store" }
+          });
+        } finally {
+          saySyntheses.delete(engine);
+        }
+      } catch (error) {
+        if (error?.name === "AbortError")
+          return Response.json(fail("cancelled", "Speech synthesis was cancelled."), {
+            status: 499
+          });
+        return Response.json(fail("synthesis-failed", "Local speech synthesis failed."), {
+          status: 502
+        });
+      }
+    }
+  });
+  ctx.effect(
+    () => async () => {
+      sayCapability();
+      saySpeech();
+      await Promise.allSettled([...saySyntheses].map((engine) => engine.stop()));
+      saySyntheses.clear();
+    },
+    "dsh-live-voice: remove say audio routes"
+  );
   const whisper = new WhisperHttpHost({ store: whisperStore, fetchImpl: whisperFetch });
   const qwen = new QwenHttpHost({ store: qwenStore, fetchImpl: qwenFetch });
   for (const endpoint of ["config", "test"]) {
@@ -967,14 +1152,15 @@ function apply(ctx, {
     fetch: async (request) => {
       try {
         const body = await request.json();
-        const bytes = await qwen.synthesize(body?.text, {
+        const wav = await qwen.synthesize(body?.text, {
           lang: body?.lang || "pt-BR",
           voice: body?.voice,
           signal: request.signal
         });
+        const bytes = await encodeHostSpeech(wav, { signal: request.signal });
         return new Response(bytes, {
           status: 200,
-          headers: { "content-type": "audio/wav", "cache-control": "no-store" }
+          headers: { "content-type": "audio/mp4", "cache-control": "no-store" }
         });
       } catch (error) {
         if (error?.name === "AbortError")
@@ -1017,8 +1203,10 @@ function apply(ctx, {
 }
 export {
   SAY_CHANNEL,
+  VOICE_CONTEXT_PATH,
   apply,
   createSayHost,
+  createVoiceContextStore,
   inject,
   name
 };