daemora 1.0.0-alpha.0

package/dist/voice/tts/TTSAdapter.d.ts

@@ -0,0 +1,46 @@
+/**
+ * TTSAdapter — provider-agnostic text-to-speech interface.
+ *
+ * All TTS providers (streaming WebSocket or HTTP) extend this class
+ * and emit a uniform set of events for the voice pipeline.
+ */
+import { EventEmitter } from "node:events";
+export interface TTSConfig {
+    apiKey: string;
+    voice?: string;
+    model?: string;
+    outputFormat?: "pcm16" | "mp3" | "opus";
+    sampleRate?: number;
+    /** Override base URL for OpenAI-compatible APIs (e.g. Groq). */
+    baseURL?: string;
+}
+export interface AudioFormat {
+    encoding: "pcm16" | "mp3" | "opus";
+    sampleRate: number;
+    channels: number;
+}
+export interface TTSEvents {
+    audio: [chunk: Buffer, format: AudioFormat];
+    flushed: [];
+    error: [error: Error];
+    close: [code?: number, reason?: string];
+}
+export declare abstract class TTSAdapter extends EventEmitter {
+    abstract readonly id: string;
+    abstract readonly streaming: boolean;
+    constructor();
+    /** Connect to the provider and prepare for synthesis. */
+    abstract connect(config: TTSConfig): Promise<void>;
+    /** Gracefully disconnect and release resources. */
+    abstract disconnect(): Promise<void>;
+    /** Feed text (or a token) into the synthesiser. */
+    abstract sendText(text: string): void;
+    /** Signal end of text input — provider should finish generating. */
+    abstract flush(): void;
+    /** Cancel current synthesis (e.g. user interrupted). */
+    abstract cancel(): void;
+    emit<K extends keyof TTSEvents>(event: K, ...args: TTSEvents[K]): boolean;
+    on<K extends keyof TTSEvents>(event: K, listener: (...args: TTSEvents[K]) => void): this;
+    once<K extends keyof TTSEvents>(event: K, listener: (...args: TTSEvents[K]) => void): this;
+}
+//# sourceMappingURL=TTSAdapter.d.ts.map

package/dist/voice/tts/TTSAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TTSAdapter.d.ts","sourceRoot":"","sources":["../../../src/voice/tts/TTSAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAI3C,MAAM,WAAW,SAAS;IACxB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACxC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAID,MAAM,WAAW,WAAW;IAC1B,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAID,MAAM,WAAW,SAAS;IACxB,KAAK,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC;IAC5C,OAAO,EAAE,EAAE,CAAC;IACZ,KAAK,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;IACtB,KAAK,EAAE,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAC;CACzC;AAID,8BAAsB,UAAW,SAAQ,YAAY;IACnD,QAAQ,CAAC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC;;IAQrC,yDAAyD;IACzD,QAAQ,CAAC,OAAO,CAAC,MAAM,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAElD,mDAAmD;IACnD,QAAQ,CAAC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAEpC,mDAAmD;IACnD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAErC,oEAAoE;IACpE,QAAQ,CAAC,KAAK,IAAI,IAAI;IAEtB,wDAAwD;IACxD,QAAQ,CAAC,MAAM,IAAI,IAAI;IAId,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,GAAG,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,GAAG,OAAO;IAIzE,EAAE,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;IAIxF,IAAI,CAAC,CAAC,SAAS,MAAM,SAAS,EAAE,KAAK,EAAE,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,KAAK,IAAI,GAAG,IAAI;CAGpG"}

package/dist/voice/tts/TTSAdapter.js

@@ -0,0 +1,26 @@
+/**
+ * TTSAdapter — provider-agnostic text-to-speech interface.
+ *
+ * All TTS providers (streaming WebSocket or HTTP) extend this class
+ * and emit a uniform set of events for the voice pipeline.
+ */
+import { EventEmitter } from "node:events";
+// ── Abstract base ───────────────────────────────────────────────────
+export class TTSAdapter extends EventEmitter {
+    constructor() {
+        super();
+        // Prevent unhandled error events from crashing the process
+        this.on("error", () => { });
+    }
+    // ── Typed emit / on helpers ─────────────────────────────────────
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    once(event, listener) {
+        return super.once(event, listener);
+    }
+}
+//# sourceMappingURL=TTSAdapter.js.map

package/dist/voice/tts/TTSAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TTSAdapter.js","sourceRoot":"","sources":["../../../src/voice/tts/TTSAdapter.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AA+B3C,uEAAuE;AAEvE,MAAM,OAAgB,UAAW,SAAQ,YAAY;IAInD;QACE,KAAK,EAAE,CAAC;QACR,2DAA2D;QAC3D,IAAI,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;IAC7B,CAAC;IAiBD,mEAAmE;IAE1D,IAAI,CAA4B,KAAQ,EAAE,GAAG,IAAkB;QACtE,OAAO,KAAK,CAAC,IAAI,CAAC,KAAe,EAAE,GAAG,IAAI,CAAC,CAAC;IAC9C,CAAC;IAEQ,EAAE,CAA4B,KAAQ,EAAE,QAAyC;QACxF,OAAO,KAAK,CAAC,EAAE,CAAC,KAAe,EAAE,QAAwC,CAAC,CAAC;IAC7E,CAAC;IAEQ,IAAI,CAA4B,KAAQ,EAAE,QAAyC;QAC1F,OAAO,KAAK,CAAC,IAAI,CAAC,KAAe,EAAE,QAAwC,CAAC,CAAC;IAC/E,CAAC;CACF"}

package/dist/voice-worker.mjs

@@ -0,0 +1,607 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/voice/ElevenLabsSTT.ts
+var ElevenLabsSTT_exports = {};
+__export(ElevenLabsSTT_exports, {
+  ElevenLabsSTT: () => ElevenLabsSTT
+});
+import { stt, mergeFrames } from "@livekit/agents";
+function createWavBuffer(frame) {
+  const bitsPerSample = 16;
+  const byteRate = frame.sampleRate * frame.channels * bitsPerSample / 8;
+  const blockAlign = frame.channels * bitsPerSample / 8;
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + frame.data.byteLength, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(frame.channels, 22);
+  header.writeUInt32LE(frame.sampleRate, 24);
+  header.writeUInt32LE(byteRate, 28);
+  header.writeUInt16LE(blockAlign, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(frame.data.byteLength, 40);
+  return Buffer.concat([header, Buffer.from(frame.data.buffer)]);
+}
+var ElevenLabsSTT;
+var init_ElevenLabsSTT = __esm({
+  "src/voice/ElevenLabsSTT.ts"() {
+    "use strict";
+    ElevenLabsSTT = class extends stt.STT {
+      label = "elevenlabs.STT";
+      opts;
+      constructor(opts) {
+        super({ streaming: false, interimResults: false });
+        this.opts = {
+          model: "scribe_v1",
+          baseURL: "https://api.elevenlabs.io/v1",
+          ...opts
+        };
+      }
+      get model() {
+        return this.opts.model;
+      }
+      get provider() {
+        return "elevenlabs";
+      }
+      async _recognize(buffer, abortSignal) {
+        const frame = mergeFrames(buffer);
+        const wav = createWavBuffer(frame);
+        const form = new FormData();
+        form.set("model_id", this.opts.model);
+        form.set(
+          "file",
+          new File([new Uint8Array(wav)], "audio.wav", { type: "audio/wav" })
+        );
+        if (this.opts.language) form.set("language_code", this.opts.language);
+        if (this.opts.timestamps) form.set("timestamps_granularity", "word");
+        if (this.opts.diarize) form.set("diarize", "true");
+        const resp = await fetch(`${this.opts.baseURL}/speech-to-text`, {
+          method: "POST",
+          headers: { "xi-api-key": this.opts.apiKey },
+          body: form,
+          ...abortSignal ? { signal: abortSignal } : {}
+        });
+        if (!resp.ok) {
+          const body = await resp.text();
+          throw new Error(`ElevenLabs STT ${resp.status}: ${body.slice(0, 200)}`);
+        }
+        const data = await resp.json();
+        return {
+          type: stt.SpeechEventType.FINAL_TRANSCRIPT,
+          alternatives: [
+            {
+              text: data.text ?? "",
+              language: data.language_code ?? this.opts.language ?? "",
+              startTime: 0,
+              endTime: 0,
+              confidence: 0
+            }
+          ]
+        };
+      }
+      stream() {
+        throw new Error("ElevenLabs STT does not support streaming \u2014 use StreamAdapter");
+      }
+    };
+  }
+});
+
+// src/voice/GroqTTS.ts
+var GroqTTS_exports = {};
+__export(GroqTTS_exports, {
+  GroqTTS: () => GroqTTS,
+  defaultVoiceForGroqModel: () => defaultVoiceForGroqModel
+});
+import { AudioByteStream, tts } from "@livekit/agents";
+function defaultVoiceForGroqModel(model) {
+  return DEFAULT_VOICE_BY_MODEL[model] ?? FALLBACK_VOICE;
+}
+async function fetchWavAsPcm(opts, text, abortSignal) {
+  if (!opts.apiKey) {
+    throw new Error("Groq TTS: GROQ_API_KEY is not set. Add it in Settings \u2192 Secrets.");
+  }
+  if (!opts.voice) {
+    throw new Error(
+      `Groq TTS: no voice configured for model "${opts.model}". Set TTS_VOICE in Settings \u2192 Voice (e.g. "Fritz-PlayAI" for PlayAI models, "tara" for Orpheus).`
+    );
+  }
+  if (!opts.model) {
+    throw new Error("Groq TTS: no model configured. Set TTS_MODEL in Settings \u2192 Voice.");
+  }
+  const resp = await fetch(`${opts.baseURL}/audio/speech`, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${opts.apiKey}`,
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      input: text,
+      model: opts.model,
+      voice: opts.voice,
+      response_format: "wav"
+    }),
+    ...abortSignal ? { signal: abortSignal } : {}
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`Groq TTS ${resp.status}: ${body.slice(0, 200)}`);
+  }
+  const buf = await resp.arrayBuffer();
+  return stripWavHeader(buf);
+}
+function stripWavHeader(buf) {
+  const view = new DataView(buf);
+  for (let i = 12; i < Math.min(buf.byteLength - 8, 256); i++) {
+    if (view.getUint8(i) === 100 && view.getUint8(i + 1) === 97 && view.getUint8(i + 2) === 116 && view.getUint8(i + 3) === 97) {
+      return buf.slice(i + 8);
+    }
+  }
+  return buf.slice(WAV_HEADER_BYTES);
+}
+function randomId() {
+  return Math.random().toString(36).slice(2);
+}
+var SAMPLE_RATE_BY_MODEL, DEFAULT_SAMPLE_RATE, CHANNELS, WAV_HEADER_BYTES, DEFAULT_VOICE_BY_MODEL, FALLBACK_VOICE, ORPHEUS_VOICES, GroqTTS, GroqChunkedStream;
+var init_GroqTTS = __esm({
+  "src/voice/GroqTTS.ts"() {
+    "use strict";
+    SAMPLE_RATE_BY_MODEL = {
+      "playai-tts": 48e3,
+      "playai-tts-english": 48e3,
+      "playai-tts-arabic": 48e3,
+      "canopylabs/orpheus-v1-english": 24e3,
+      "orpheus-v1-english": 24e3
+    };
+    DEFAULT_SAMPLE_RATE = 24e3;
+    CHANNELS = 1;
+    WAV_HEADER_BYTES = 44;
+    DEFAULT_VOICE_BY_MODEL = {
+      "playai-tts": "Fritz-PlayAI",
+      "playai-tts-english": "Fritz-PlayAI",
+      "playai-tts-arabic": "Ahmad-PlayAI",
+      // Groq Orpheus accepts only [autumn, diana, hannah, austin, daniel, troy]
+      // — older "tara" / "leah" names from upstream Orpheus are rejected
+      // (400 invalid_request_error). Picking `troy` as a neutral male voice;
+      // override per-deploy via TTS_VOICE setting.
+      "canopylabs/orpheus-v1-english": "troy",
+      "orpheus-v1-english": "troy"
+    };
+    FALLBACK_VOICE = "Fritz-PlayAI";
+    ORPHEUS_VOICES = /* @__PURE__ */ new Set(["autumn", "diana", "hannah", "austin", "daniel", "troy"]);
+    GroqTTS = class extends tts.TTS {
+      label = "groq.TTS";
+      opts;
+      constructor(opts) {
+        const rate = opts.sampleRate ?? SAMPLE_RATE_BY_MODEL[opts.model] ?? DEFAULT_SAMPLE_RATE;
+        super(rate, CHANNELS, { streaming: false });
+        let voice2 = opts.voice && opts.voice.trim() !== "" ? opts.voice.toLowerCase() : defaultVoiceForGroqModel(opts.model);
+        if (/orpheus/.test(opts.model) && !ORPHEUS_VOICES.has(voice2)) {
+          voice2 = defaultVoiceForGroqModel(opts.model);
+        }
+        this.opts = {
+          baseURL: "https://api.groq.com/openai/v1",
+          ...opts,
+          voice: voice2,
+          sampleRate: rate
+        };
+      }
+      get model() {
+        return this.opts.model;
+      }
+      get provider() {
+        return "groq";
+      }
+      synthesize(text, connOptions, abortSignal) {
+        const audioPromise = fetchWavAsPcm(this.opts, text, abortSignal);
+        return new GroqChunkedStream(
+          this,
+          text,
+          audioPromise,
+          this.opts.sampleRate,
+          connOptions,
+          abortSignal
+        );
+      }
+      stream() {
+        throw new Error("GroqTTS does not support streaming synthesis");
+      }
+    };
+    GroqChunkedStream = class extends tts.ChunkedStream {
+      label = "groq.ChunkedStream";
+      pcmPromise;
+      sampleRate;
+      constructor(ttsRef, text, pcmPromise, sampleRate, connOptions, abortSignal) {
+        super(text, ttsRef, connOptions, abortSignal);
+        this.pcmPromise = pcmPromise;
+        this.sampleRate = sampleRate;
+      }
+      async run() {
+        const requestId = randomId();
+        const stream = new AudioByteStream(this.sampleRate, CHANNELS);
+        const queue = this.queue;
+        const silenceMs = 120;
+        const silenceBytes = new ArrayBuffer(Math.floor(this.sampleRate * silenceMs / 1e3) * 2);
+        for (const f of stream.write(silenceBytes)) {
+          queue.put({ requestId, segmentId: "0", frame: f, final: false });
+        }
+        try {
+          const pcm = await this.pcmPromise;
+          const frames = stream.write(pcm);
+          let last;
+          const emit = (segmentId, final) => {
+            if (!last) return;
+            queue.put({ requestId, segmentId, frame: last, final });
+            last = void 0;
+          };
+          for (const frame of frames) {
+            emit("0", false);
+            last = frame;
+          }
+          emit("0", true);
+        } catch (err) {
+          if (err instanceof Error && err.name === "AbortError") return;
+          throw err;
+        } finally {
+          queue.close();
+        }
+      }
+    };
+  }
+});
+
+// src/voice/VoiceAgent.ts
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  ServerOptions,
+  cli,
+  defineAgent,
+  voice
+} from "@livekit/agents";
+import * as silero from "@livekit/agents-plugin-silero";
+
+// src/voice/DaemoraLLM.ts
+import { randomUUID } from "node:crypto";
+import { llm } from "@livekit/agents";
+var VOICE_SESSION_ID = "main";
+var DaemoraLLM = class extends llm.LLM {
+  daemoraUrl;
+  modelId;
+  constructor(opts) {
+    super();
+    this.daemoraUrl = opts.daemoraUrl.replace(/\/$/, "");
+    this.modelId = opts.model ?? "daemora";
+  }
+  label() {
+    return "daemora.LLM";
+  }
+  get model() {
+    return this.modelId;
+  }
+  get provider() {
+    return "daemora";
+  }
+  chat({
+    chatCtx,
+    toolCtx,
+    connOptions
+  }) {
+    return new DaemoraLLMStream(this, {
+      chatCtx,
+      ...toolCtx ? { toolCtx } : {},
+      ...connOptions ? { connOptions } : {}
+    });
+  }
+};
+var DaemoraLLMStream = class extends llm.LLMStream {
+  daemora;
+  constructor(daemora, opts) {
+    const connOptions = opts.connOptions ?? { maxRetry: 0, timeoutMs: 12e4 };
+    if (opts.toolCtx) {
+      super(daemora, { chatCtx: opts.chatCtx, toolCtx: opts.toolCtx, connOptions });
+    } else {
+      super(daemora, { chatCtx: opts.chatCtx, connOptions });
+    }
+    this.daemora = daemora;
+  }
+  async run() {
+    const userText = extractLatestUserText(this.chatCtx);
+    const chunkId = randomUUID();
+    if (!userText) {
+      this.queue.close();
+      return;
+    }
+    try {
+      const kickoff = await fetch(`${this.daemora.daemoraUrl}/api/chat`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          input: userText,
+          sessionId: VOICE_SESSION_ID,
+          // Flag: ask the server to add a "voice mode" prelude to the
+          // system prompt so the reply is spoken-style (no markdown,
+          // 1–3 short sentences). TTS reads bullet points and pipe
+          // characters out loud otherwise.
+          voiceMode: true
+        }),
+        signal: this.abortController.signal
+      });
+      if (!kickoff.ok) {
+        throw new Error(`/api/chat ${kickoff.status}`);
+      }
+      const { taskId } = await kickoff.json();
+      await this.consumeSSE(`${this.daemora.daemoraUrl}/api/tasks/${taskId}/stream`, chunkId);
+    } catch (err) {
+      if (!this.abortController.signal.aborted) {
+        throw err;
+      }
+    } finally {
+      this.queue.close();
+    }
+  }
+  /**
+   * Minimal SSE parser — reads `event:` / `data:` lines and routes
+   * text deltas to the LLMStream queue. Terminates on `task:state`
+   * with a completed / failed status, or when the stream ends.
+   */
+  async consumeSSE(url, chunkId) {
+    const resp = await fetch(url, {
+      method: "GET",
+      headers: { Accept: "text/event-stream" },
+      signal: this.abortController.signal
+    });
+    if (!resp.ok || !resp.body) throw new Error(`SSE ${resp.status}`);
+    const reader = resp.body.getReader();
+    const decoder = new TextDecoder();
+    let buf = "";
+    let currentEvent = "";
+    while (true) {
+      if (this.abortController.signal.aborted) {
+        try {
+          await reader.cancel();
+        } catch {
+        }
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (done) return;
+      buf += decoder.decode(value, { stream: true });
+      let idx;
+      while ((idx = buf.indexOf("\n")) >= 0) {
+        const line = buf.slice(0, idx).replace(/\r$/, "");
+        buf = buf.slice(idx + 1);
+        if (line.startsWith("event:")) {
+          currentEvent = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          const dataRaw = line.slice(5).trim();
+          if (!dataRaw) continue;
+          let payload;
+          try {
+            payload = JSON.parse(dataRaw);
+          } catch {
+            continue;
+          }
+          if (currentEvent === "text:delta") {
+            const delta = payload.delta;
+            if (delta) {
+              this.queue.put({
+                id: chunkId,
+                delta: { role: "assistant", content: delta }
+              });
+            }
+          } else if (currentEvent === "task:state") {
+            const status = payload.status;
+            if (status === "completed" || status === "failed") return;
+          }
+        }
+      }
+    }
+  }
+};
+function extractLatestUserText(ctx) {
+  const items = ctx.items;
+  for (let i = items.length - 1; i >= 0; i--) {
+    const item = items[i];
+    if (!item) continue;
+    if (item.type !== "message") continue;
+    const msg = item;
+    if (msg.role !== "user") continue;
+    const text = msg.textContent;
+    if (text && text.trim()) return text.trim();
+  }
+  return "";
+}
+
+// src/voice/VoiceAgent.ts
+var SOUL_PROMPT;
+try {
+  SOUL_PROMPT = readFileSync(join(dirname(fileURLToPath(import.meta.url)), "../../SOUL.md"), "utf-8").trim();
+} catch {
+  SOUL_PROMPT = "You are Daemora \u2014 a personal AI agent. Be warm, natural, and helpful.";
+}
+process.on("unhandledRejection", (reason) => {
+  const err = reason;
+  const inner = err?.error instanceof Error ? err.error.message : String(err?.error ?? reason);
+  const label = err?.label ?? "voice";
+  const type = err?.type ?? "unknown";
+  console.error(`[voice] [${type}] ${label}: ${inner}`);
+});
+var VoiceAgent_default = defineAgent({
+  prewarm: async (proc) => {
+    proc.userData.vad = await silero.VAD.load();
+  },
+  entry: async (ctx) => {
+    const daemoraUrl = process.env["DAEMORA_HTTP"] ?? "http://127.0.0.1:8081";
+    const stt2 = await buildSTT();
+    const tts2 = await buildTTS();
+    const agentLlm = new DaemoraLLM({ daemoraUrl });
+    const agent = new voice.Agent({
+      instructions: SOUL_PROMPT + "\n\n## Voice Mode Active\nYou are speaking via voice right now. Keep responses short and natural \u2014 no markdown, no code blocks, no bullets. React with emotion."
+    });
+    const session = new voice.AgentSession({
+      stt: stt2,
+      llm: agentLlm,
+      tts: tts2,
+      vad: ctx.proc.userData.vad,
+      // Daemora's agent loop can take 20+ seconds for tool-heavy turns
+      // (shell commands, file reads, web fetches). LiveKit's preemptive
+      // generation fires TTS synthesis the moment a user transcript is
+      // finalised and expects text to start flowing within ~10 s; if
+      // none arrives it closes the stream as stalled. Disable it so
+      // TTS only runs against a complete, in-hand response.
+      preemptiveGeneration: false
+    });
+    await session.start({
+      agent,
+      room: ctx.room,
+      // Keep the agent alive when the user disconnects. Otherwise the
+      // session closes → the worker tears down → rtc-node's C++
+      // teardown hits its mutex bug and crashes → auto-respawn burns
+      // ~25s before the worker is registered again, so a second mic
+      // tap within that window never gets an agent.
+      inputOptions: { closeOnDisconnect: false }
+    });
+    await ctx.connect();
+    session.generateReply({
+      instructions: "Greet the user warmly and naturally. You are Daemora. Be brief \u2014 one sentence, like a friend picking up the phone."
+    });
+  }
+});
+async function buildSTT() {
+  const provider = (process.env["DAEMORA_STT_PROVIDER"] || void 0) ?? inferDefaultStt();
+  const modelRaw = process.env["STT_MODEL"] || process.env["DAEMORA_STT_MODEL"] || void 0;
+  const model = stripProviderPrefix(modelRaw, provider);
+  switch (provider) {
+    case "deepgram": {
+      const apiKey = process.env["DEEPGRAM_API_KEY"];
+      if (!apiKey) throw new Error("DEEPGRAM_API_KEY not set");
+      const { STT } = await import("@livekit/agents-plugin-deepgram");
+      return new STT({
+        apiKey,
+        ...model ? { model } : {}
+      });
+    }
+    case "elevenlabs": {
+      const apiKey = process.env["ELEVENLABS_API_KEY"];
+      if (!apiKey) throw new Error("ELEVENLABS_API_KEY not set");
+      const language = process.env["STT_LANGUAGE"];
+      const { ElevenLabsSTT: ElevenLabsSTT2 } = await Promise.resolve().then(() => (init_ElevenLabsSTT(), ElevenLabsSTT_exports));
+      return new ElevenLabsSTT2({
+        apiKey,
+        ...model ? { model } : {},
+        ...language ? { language } : {}
+      });
+    }
+    case "groq": {
+      const apiKey = process.env["GROQ_API_KEY"];
+      if (!apiKey) throw new Error("GROQ_API_KEY not set");
+      const { STT } = await import("@livekit/agents-plugin-openai");
+      return STT.withGroq({
+        apiKey,
+        ...model ? { model } : {}
+      });
+    }
+    case "openai":
+    default: {
+      const apiKey = process.env["OPENAI_API_KEY"];
+      if (!apiKey) throw new Error("OPENAI_API_KEY not set");
+      const { STT } = await import("@livekit/agents-plugin-openai");
+      return new STT({
+        apiKey,
+        ...model ? { model } : { model: "whisper-1" }
+      });
+    }
+  }
+}
+async function buildTTS() {
+  const provider = (process.env["DAEMORA_TTS_PROVIDER"] || void 0) ?? inferDefaultTts();
+  const modelRaw = process.env["TTS_MODEL"] || process.env["DAEMORA_TTS_MODEL"] || void 0;
+  const model = stripProviderPrefix(modelRaw, provider);
+  const voice2 = process.env["TTS_VOICE"] || process.env["DAEMORA_TTS_VOICE"] || void 0;
+  switch (provider) {
+    case "cartesia": {
+      const apiKey = process.env["CARTESIA_API_KEY"];
+      if (!apiKey) throw new Error("CARTESIA_API_KEY not set");
+      const { TTS } = await import("@livekit/agents-plugin-cartesia");
+      return new TTS({
+        apiKey,
+        ...model ? { model } : {},
+        ...voice2 ? { voice: voice2 } : {}
+      });
+    }
+    case "elevenlabs": {
+      const apiKey = process.env["ELEVENLABS_API_KEY"];
+      if (!apiKey) throw new Error("ELEVENLABS_API_KEY not set");
+      const language = process.env["TTS_LANGUAGE"] ?? process.env["DAEMORA_TTS_LANGUAGE"];
+      const { TTS } = await import("@livekit/agents-plugin-elevenlabs");
+      return new TTS({
+        apiKey,
+        ...model ? { model } : { model: "eleven_turbo_v2_5" },
+        ...voice2 ? { voiceId: voice2 } : {},
+        ...language ? { language } : {}
+      });
+    }
+    case "groq": {
+      const apiKey = process.env["GROQ_API_KEY"];
+      if (!apiKey) throw new Error("GROQ_API_KEY not set");
+      const { GroqTTS: GroqTTS2 } = await Promise.resolve().then(() => (init_GroqTTS(), GroqTTS_exports));
+      return new GroqTTS2({
+        apiKey,
+        model: model ?? "playai-tts-english",
+        voice: voice2 ?? "Fritz-PlayAI"
+      });
+    }
+    case "openai":
+    default: {
+      const apiKey = process.env["OPENAI_API_KEY"];
+      if (!apiKey) throw new Error("OPENAI_API_KEY not set");
+      const { TTS } = await import("@livekit/agents-plugin-openai");
+      return new TTS({
+        apiKey,
+        ...model ? { model } : { model: "gpt-4o-mini-tts" },
+        ...voice2 ? { voice: voice2 } : { voice: "nova" }
+      });
+    }
+  }
+}
+function stripProviderPrefix(model, provider) {
+  if (!model) return void 0;
+  const prefix = `${provider}/`;
+  if (model.toLowerCase().startsWith(prefix)) return model.slice(prefix.length);
+  const colonPrefix = `${provider}:`;
+  if (model.toLowerCase().startsWith(colonPrefix)) return model.slice(colonPrefix.length);
+  return model;
+}
+function inferDefaultStt() {
+  if (process.env["DEEPGRAM_API_KEY"]) return "deepgram";
+  if (process.env["GROQ_API_KEY"]) return "groq";
+  return "openai";
+}
+function inferDefaultTts() {
+  if (process.env["CARTESIA_API_KEY"]) return "cartesia";
+  if (process.env["ELEVENLABS_API_KEY"]) return "elevenlabs";
+  if (process.env["GROQ_API_KEY"]) return "groq";
+  return "openai";
+}
+cli.runApp(
+  new ServerOptions({
+    agent: fileURLToPath(import.meta.url),
+    agentName: "daemora"
+  })
+);
+export {
+  VoiceAgent_default as default
+};