@elizaos/ui 2.0.3-beta.2 → 2.0.3-beta.4

package/voice/playback-frame-pump.js

@@ -0,0 +1,387 @@
+/**
+ * Web Audio -> agent playback-reference pump for live echo cancellation.
+ *
+ * The live diarization route accepts the agent's own TTS playback as far-end
+ * reference frames at `/api/voice/playback-frames`. This helper taps decoded
+ * Web Audio playback in real time, downmixes/resamples to 16 kHz mono, encodes
+ * 20 ms LE-s16 frames, and posts them in batches. The route is optional: a
+ * missing local diarization backend must never break audible TTS playback.
+ */
+import { fetchWithCsrf } from "../api/csrf-client.js";
+import { resolveApiUrl } from "../utils/index.js";
+const PLAYBACK_FRAMES_PATH = "/api/voice/playback-frames";
+const TARGET_SAMPLE_RATE = 16_000;
+const FRAME_MS = 20;
+const MAX_BATCH_FRAMES = 49;
+const FLUSH_INTERVAL_MS = 250;
+const WORKLET_NAME = "eliza-playback-reference-tap";
+const WORKLET_SOURCE = `
+class ElizaPlaybackReferenceTap extends AudioWorkletProcessor {
+  process(inputs) {
+    const input = inputs[0] || [];
+    const first = input[0];
+    if (first && first.length > 0) {
+      const mono = new Float32Array(first.length);
+      const channels = Math.max(1, input.length);
+      for (let i = 0; i < first.length; i += 1) {
+        let sum = 0;
+        let count = 0;
+        for (let ch = 0; ch < channels; ch += 1) {
+          const channel = input[ch];
+          if (channel) {
+            sum += channel[i] || 0;
+            count += 1;
+          }
+        }
+        mono[i] = count > 0 ? sum / count : 0;
+      }
+      this.port.postMessage({ pcm: mono, sampleRate }, [mono.buffer]);
+    }
+    return true;
+  }
+}
+registerProcessor("${WORKLET_NAME}", ElizaPlaybackReferenceTap);
+`;
+const workletModules = new WeakMap();
+function getNowMs() {
+    return typeof performance !== "undefined" ? performance.now() : Date.now();
+}
+function hasAudioWorklet(ctx) {
+    return (typeof ctx.audioWorklet?.addModule === "function" &&
+        typeof AudioWorkletNode !== "undefined" &&
+        typeof Blob !== "undefined" &&
+        typeof URL !== "undefined" &&
+        typeof URL.createObjectURL === "function");
+}
+async function ensurePlaybackWorklet(ctx) {
+    const existing = workletModules.get(ctx);
+    if (existing)
+        return existing;
+    const pending = (async () => {
+        const url = URL.createObjectURL(new Blob([WORKLET_SOURCE], { type: "text/javascript" }));
+        try {
+            await ctx.audioWorklet.addModule(url);
+        }
+        finally {
+            URL.revokeObjectURL(url);
+        }
+    })();
+    workletModules.set(ctx, pending);
+    return pending;
+}
+function clampPcm(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    return Math.max(-1, Math.min(1, value));
+}
+function encodePcm16Base64(pcm) {
+    const bytes = new Uint8Array(pcm.length * 2);
+    const view = new DataView(bytes.buffer);
+    for (let i = 0; i < pcm.length; i += 1) {
+        const clamped = clampPcm(pcm[i] ?? 0);
+        const int16 = clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff;
+        view.setInt16(i * 2, Math.round(int16), true);
+    }
+    const maybeBuffer = globalThis.Buffer;
+    if (maybeBuffer)
+        return maybeBuffer.from(bytes).toString("base64");
+    const btoaFn = globalThis.btoa;
+    if (!btoaFn) {
+        throw new Error("[playback-frame-pump] no base64 encoder available");
+    }
+    let binary = "";
+    for (let i = 0; i < bytes.length; i += 1) {
+        binary += String.fromCharCode(bytes[i] ?? 0);
+    }
+    return btoaFn(binary);
+}
+function measureRms(pcm) {
+    if (pcm.length === 0)
+        return 0;
+    let sumSquares = 0;
+    for (let i = 0; i < pcm.length; i += 1) {
+        const value = clampPcm(pcm[i] ?? 0);
+        sumSquares += value * value;
+    }
+    return Math.sqrt(sumSquares / pcm.length);
+}
+export function downmixAudioBufferToMono(buffer) {
+    const channels = Math.max(1, buffer.numberOfChannels);
+    const out = new Float32Array(buffer.length);
+    for (let ch = 0; ch < channels; ch += 1) {
+        const data = buffer.getChannelData(ch);
+        for (let i = 0; i < out.length; i += 1) {
+            out[i] += (data[i] ?? 0) / channels;
+        }
+    }
+    return out;
+}
+class StreamingLinearResampler {
+    sourceRate;
+    targetRate;
+    pending = new Float32Array(0);
+    sourcePosition = 0;
+    constructor(sourceRate, targetRate) {
+        this.sourceRate = sourceRate;
+        this.targetRate = targetRate;
+    }
+    push(input) {
+        if (input.length === 0)
+            return new Float32Array(0);
+        if (this.sourceRate === this.targetRate)
+            return input.slice();
+        const combined = new Float32Array(this.pending.length + input.length);
+        combined.set(this.pending);
+        combined.set(input, this.pending.length);
+        const step = this.sourceRate / this.targetRate;
+        const out = [];
+        while (this.sourcePosition + 1 < combined.length) {
+            const i0 = Math.floor(this.sourcePosition);
+            const i1 = i0 + 1;
+            const frac = this.sourcePosition - i0;
+            const s0 = combined[i0] ?? 0;
+            const s1 = combined[i1] ?? s0;
+            out.push(s0 + (s1 - s0) * frac);
+            this.sourcePosition += step;
+        }
+        const drop = Math.max(0, Math.floor(this.sourcePosition) - 1);
+        this.pending = combined.slice(drop);
+        this.sourcePosition -= drop;
+        return Float32Array.from(out);
+    }
+}
+export function resamplePcmTo16k(pcm, sourceSampleRate) {
+    return new StreamingLinearResampler(sourceSampleRate, TARGET_SAMPLE_RATE).push(pcm);
+}
+function concatFloat32(a, b) {
+    if (a.length === 0)
+        return b.slice();
+    if (b.length === 0)
+        return a;
+    const out = new Float32Array(a.length + b.length);
+    out.set(a);
+    out.set(b, a.length);
+    return out;
+}
+class PlaybackFrameSession {
+    endpointPath;
+    targetSampleRate;
+    frameMs;
+    frameSamples;
+    maxBatchFrames;
+    flushIntervalMs;
+    nowMs;
+    fetcher;
+    disconnectTap;
+    resampler = null;
+    resamplerRate = 0;
+    pending = new Float32Array(0);
+    batch = [];
+    sending = Promise.resolve();
+    flushTimer = null;
+    running = false;
+    failed = false;
+    frameIndex = 0;
+    startTimestampMs = 0;
+    constructor(options) {
+        this.endpointPath = options.endpointPath;
+        this.targetSampleRate = options.targetSampleRate;
+        this.frameMs = options.frameMs;
+        this.frameSamples = Math.round((options.targetSampleRate * options.frameMs) / 1000);
+        this.maxBatchFrames = options.maxBatchFrames;
+        this.flushIntervalMs = options.flushIntervalMs;
+        this.nowMs = options.nowMs;
+        this.fetcher = options.fetcher;
+        this.disconnectTap = options.disconnectTap ?? null;
+    }
+    start(startTimestampMs = this.nowMs()) {
+        if (this.running)
+            return;
+        this.running = true;
+        this.startTimestampMs = startTimestampMs;
+        this.flushTimer = setInterval(() => {
+            void this.flush(false);
+        }, this.flushIntervalMs);
+    }
+    appendPcm(pcm, sampleRate) {
+        if (!this.running || this.failed || pcm.length === 0)
+            return;
+        if (!this.resampler || this.resamplerRate !== sampleRate) {
+            this.resampler = new StreamingLinearResampler(sampleRate, this.targetSampleRate);
+            this.resamplerRate = sampleRate;
+        }
+        const resampled = this.resampler.push(pcm);
+        this.pending = concatFloat32(this.pending, resampled);
+        while (this.pending.length >= this.frameSamples) {
+            const framePcm = this.pending.slice(0, this.frameSamples);
+            this.pending = this.pending.slice(this.frameSamples);
+            this.batch.push(this.buildFrame(framePcm));
+            if (this.batch.length >= this.maxBatchFrames) {
+                void this.flush(false);
+            }
+        }
+    }
+    async stop(options = {}) {
+        if (!this.running && !options.reset)
+            return;
+        this.running = false;
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+            this.flushTimer = null;
+        }
+        this.disconnectTap?.();
+        await this.flush(false);
+        await this.sending;
+        if (options.reset) {
+            await this.post([], true);
+        }
+    }
+    buildFrame(pcm) {
+        const index = this.frameIndex;
+        this.frameIndex += 1;
+        return {
+            pcm16: encodePcm16Base64(pcm),
+            sampleRate: this.targetSampleRate,
+            channels: 1,
+            samples: pcm.length,
+            rms: measureRms(pcm),
+            timestamp: this.startTimestampMs + index * this.frameMs,
+            frameIndex: index,
+        };
+    }
+    async flush(final) {
+        if (this.batch.length === 0 && !final)
+            return;
+        const frames = this.batch;
+        this.batch = [];
+        this.sending = this.sending.then(() => this.post(frames, false));
+        return this.sending;
+    }
+    async post(frames, reset) {
+        if (this.failed || (frames.length === 0 && !reset))
+            return;
+        try {
+            const res = await this.fetcher(resolveApiUrl(this.endpointPath), {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    ...(frames.length > 0 ? { frames } : {}),
+                    ...(reset ? { reset: true } : {}),
+                }),
+            });
+            if (!res.ok)
+                this.failed = true;
+        }
+        catch {
+            this.failed = true;
+        }
+    }
+}
+export class PlaybackFramePump {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            endpointPath: options.endpointPath ?? PLAYBACK_FRAMES_PATH,
+            targetSampleRate: options.targetSampleRate ?? TARGET_SAMPLE_RATE,
+            frameMs: options.frameMs ?? FRAME_MS,
+            maxBatchFrames: options.maxBatchFrames ?? MAX_BATCH_FRAMES,
+            flushIntervalMs: options.flushIntervalMs ?? FLUSH_INTERVAL_MS,
+            nowMs: options.nowMs ?? getNowMs,
+            fetcher: options.fetcher ?? fetchWithCsrf,
+        };
+    }
+    async tapSource(ctx, source, fallbackBuffer) {
+        const workletSession = await this.createWorkletSession(ctx, source).catch(() => null);
+        if (workletSession)
+            return workletSession;
+        return this.createScheduledBufferSession(fallbackBuffer);
+    }
+    createSessionForTest() {
+        return new PlaybackFrameSession(this.options);
+    }
+    async createWorkletSession(ctx, source) {
+        if (!hasAudioWorklet(ctx))
+            return null;
+        await ensurePlaybackWorklet(ctx);
+        const node = new AudioWorkletNode(ctx, WORKLET_NAME, {
+            numberOfInputs: 1,
+            numberOfOutputs: 1,
+            outputChannelCount: [1],
+        });
+        const silentGain = ctx.createGain();
+        silentGain.gain.value = 0;
+        source.connect(node);
+        node.connect(silentGain);
+        silentGain.connect(ctx.destination);
+        const session = new PlaybackFrameSession({
+            ...this.options,
+            disconnectTap: () => {
+                node.port.onmessage = null;
+                try {
+                    source.disconnect(node);
+                }
+                catch {
+                    /* ok */
+                }
+                try {
+                    node.disconnect();
+                }
+                catch {
+                    /* ok */
+                }
+                try {
+                    silentGain.disconnect();
+                }
+                catch {
+                    /* ok */
+                }
+            },
+        });
+        node.port.onmessage = (event) => {
+            const pcm = event.data?.pcm;
+            const sampleRate = event.data?.sampleRate;
+            if (pcm instanceof Float32Array && typeof sampleRate === "number") {
+                session.appendPcm(pcm, sampleRate);
+            }
+        };
+        return session;
+    }
+    createScheduledBufferSession(buffer) {
+        const session = new PlaybackFrameSession(this.options);
+        const sourceRate = buffer.sampleRate;
+        const mono = downmixAudioBufferToMono(buffer);
+        let offset = 0;
+        let timer = null;
+        const samplesPerTick = Math.max(1, Math.round((sourceRate * this.options.frameMs) / 1000));
+        return {
+            start: (startTimestampMs) => {
+                session.start(startTimestampMs);
+                timer = setInterval(() => {
+                    if (offset >= mono.length) {
+                        if (timer)
+                            clearInterval(timer);
+                        timer = null;
+                        return;
+                    }
+                    const next = mono.slice(offset, offset + samplesPerTick);
+                    offset += samplesPerTick;
+                    session.appendPcm(next, sourceRate);
+                }, this.options.frameMs);
+            },
+            stop: async (options) => {
+                if (timer) {
+                    clearInterval(timer);
+                    timer = null;
+                }
+                if (options?.drain !== false) {
+                    while (offset < mono.length) {
+                        const next = mono.slice(offset, offset + samplesPerTick);
+                        offset += samplesPerTick;
+                        session.appendPcm(next, sourceRate);
+                    }
+                }
+                await session.stop(options);
+            },
+        };
+    }
+}

package/voice/should-respond.d.ts

@@ -1,36 +1,11 @@
 /**
- * Client-side shouldRespond gate for always-on voice.
+ * Client-side shouldRespond / echo-rejection gate for always-on voice.
  *
- * In always-on ("hands-free") mode the mic is open continuously, so the
- * recognizer transcribes EVERYTHING it hears — including the agent's own
- * text-to-speech bleeding back into the mic, and the speaker's disfluent
- * thinking noises ("um…", "uh…"). Sending those as turns makes the agent reply
- * to itself or to filler — the "responding when it's not appropriate" problem.
- *
- * This is a conservative gate: it only suppresses turns we're confident are NOT
- * directed requests — pure disfluency, or a near-verbatim echo of what the agent
- * just said. Everything else (real questions, commands, even short answers like
- * "yes"/"stop") passes through. The full semantic shouldRespond (wake-word /
- * direct-address / the server `core.voice_turn_signal` evaluator) is a separate,
- * heavier layer; this handles the two cases that actually annoy users today.
- */
-export interface ShouldRespondContext {
-    /** The agent's most recent spoken reply, for the echo guard. */
-    recentAgentReply?: string;
-    /** Age of that reply in ms; the echo guard applies while it's recent. */
-    replyAgeMs?: number;
-    /**
-     * True while the agent is CURRENTLY speaking. Forces the echo guard on
-     * regardless of `replyAgeMs`, because a long reply's TTS is actively bleeding
-     * into the open mic even though its message was created many seconds ago (the
-     * age-only window would have already expired mid-speech).
-     */
-    agentSpeaking?: boolean;
-}
-/**
- * Whether a transcribed voice turn should be sent to the agent (i.e. warrants a
- * response). Returns false for pure disfluency and for near-verbatim echoes of
- * the agent's recent speech.
+ * The implementation is the canonical, pure definition in
+ * `@elizaos/shared/voice/respond-gate` — the SAME code the Voice Workbench
+ * headless runner exercises (issue #8785), so what we test is exactly what the
+ * client ships. This module re-exports it to keep the existing
+ * `@elizaos/ui` `voice/should-respond` import path (and its tests) stable.
  */
-export declare function shouldRespondToVoiceTurn(transcript: string, context?: ShouldRespondContext): boolean;
+export { ECHO_OVERLAP_THRESHOLD, ECHO_WINDOW_MS, type ShouldRespondContext, shouldRespondToVoiceTurn, } from "@elizaos/shared/voice/respond-gate";
 //# sourceMappingURL=should-respond.d.ts.map

package/voice/should-respond.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"should-respond.d.ts","sourceRoot":"","sources":["../../../../../src/voice/should-respond.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAgCH,MAAM,WAAW,oBAAoB;IACnC,gEAAgE;IAChE,gBAAgB,CAAC,EAAE,MAAM,CAAC;IAC1B,yEAAyE;IACzE,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAuBT"}
+{"version":3,"file":"should-respond.d.ts","sourceRoot":"","sources":["../../../../../src/voice/should-respond.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,sBAAsB,EACtB,cAAc,EACd,KAAK,oBAAoB,EACzB,wBAAwB,GACzB,MAAM,oCAAoC,CAAC"}

package/voice/should-respond.js

@@ -1,71 +1,10 @@
 /**
- * Client-side shouldRespond gate for always-on voice.
+ * Client-side shouldRespond / echo-rejection gate for always-on voice.
  *
- * In always-on ("hands-free") mode the mic is open continuously, so the
- * recognizer transcribes EVERYTHING it hears — including the agent's own
- * text-to-speech bleeding back into the mic, and the speaker's disfluent
- * thinking noises ("um…", "uh…"). Sending those as turns makes the agent reply
- * to itself or to filler — the "responding when it's not appropriate" problem.
- *
- * This is a conservative gate: it only suppresses turns we're confident are NOT
- * directed requests — pure disfluency, or a near-verbatim echo of what the agent
- * just said. Everything else (real questions, commands, even short answers like
- * "yes"/"stop") passes through. The full semantic shouldRespond (wake-word /
- * direct-address / the server `core.voice_turn_signal` evaluator) is a separate,
- * heavier layer; this handles the two cases that actually annoy users today.
- */
-/** Pure disfluencies — never a meaningful turn on their own. NOT answers. */
-const DISFLUENCIES = new Set([
-    "um",
-    "uh",
-    "uhh",
-    "uhm",
-    "umm",
-    "hmm",
-    "hm",
-    "mm",
-    "mmm",
-    "er",
-    "erm",
-    "ah",
-    "eh",
-]);
-/** How recent the agent's reply must be for the echo guard to apply. */
-const ECHO_WINDOW_MS = 9000;
-/** Word-overlap fraction above which a turn is treated as TTS echo. */
-const ECHO_OVERLAP_THRESHOLD = 0.7;
-function words(text) {
-    return text
-        .toLowerCase()
-        .replace(/[^a-z0-9'\s-]/gi, "")
-        .split(/\s+/)
-        .filter(Boolean);
-}
-/**
- * Whether a transcribed voice turn should be sent to the agent (i.e. warrants a
- * response). Returns false for pure disfluency and for near-verbatim echoes of
- * the agent's recent speech.
+ * The implementation is the canonical, pure definition in
+ * `@elizaos/shared/voice/respond-gate` — the SAME code the Voice Workbench
+ * headless runner exercises (issue #8785), so what we test is exactly what the
+ * client ships. This module re-exports it to keep the existing
+ * `@elizaos/ui` `voice/should-respond` import path (and its tests) stable.
  */
-export function shouldRespondToVoiceTurn(transcript, context = {}) {
-    const w = words(transcript);
-    if (w.length === 0)
-        return false;
-    // Pure disfluency ("um", "uh huh"… with nothing substantive) → ignore.
-    if (w.every((word) => DISFLUENCIES.has(word)))
-        return false;
-    // Self-echo: the agent's own TTS heard back through the mic. Only consider it
-    // while the reply is recent, and only for multi-word turns (a one-word answer
-    // shouldn't be suppressed just because the word also appears in the reply).
-    const reply = context.recentAgentReply?.trim();
-    const age = context.replyAgeMs ?? Number.POSITIVE_INFINITY;
-    const echoActive = context.agentSpeaking === true || age <= ECHO_WINDOW_MS;
-    if (reply && echoActive && w.length >= 2) {
-        const replyWords = new Set(words(reply));
-        if (replyWords.size > 0) {
-            const overlap = w.filter((word) => replyWords.has(word)).length / w.length;
-            if (overlap >= ECHO_OVERLAP_THRESHOLD)
-                return false;
-        }
-    }
-    return true;
-}
+export { ECHO_OVERLAP_THRESHOLD, ECHO_WINDOW_MS, shouldRespondToVoiceTurn, } from "@elizaos/shared/voice/respond-gate";

package/voice/useVoiceConfig.d.ts

@@ -1,4 +1,4 @@
-import type { VoiceConfig } from "../api/client-types-config";
+import type { VoiceConfig } from "../api/client-types-config.js";
 export interface UseVoiceConfigResult {
     /** Saved voice config with platform/runtime provider defaults applied. Never null. */
     voiceConfig: VoiceConfig;

package/voice/voice-capture-factory.d.ts

@@ -17,8 +17,8 @@
  * underlying primitives ({@link startLocalAsrRecorder} + browser
  * `SpeechRecognition`). This factory adds nothing on top besides routing.
  */
-import type { AsrProvider } from "../api/client-types-config";
-import { type LocalAsrAutoStopOptions } from "./local-asr-capture";
+import type { AsrProvider } from "../api/client-types-config.js";
+import { type LocalAsrAutoStopOptions } from "./local-asr-capture.js";
 /** Backend the factory ended up using for the current capture. */
 export type VoiceCaptureBackend = "local-inference" | "browser" | "talkmode";
 /** Single transcript chunk delivered to the caller. */

package/voice/voice-capture-factory.js

@@ -26,7 +26,7 @@ import { getSpeechRecognitionCtor, TALKMODE_STOP_SETTLE_MS, } from "./voice-chat
  * True on a native mobile platform whose `TalkMode` plugin is present. On
  * Android/iOS the OS speech recognizer (exposed by TalkMode) is the real STT
  * engine — it transcribes on-device with live INTERIM results — and the
- * local-inference whisper assets are not staged on mobile, so that path 502s.
+ * local-inference ASR assets are not staged on mobile, so that path 502s.
  * `getNativePlugin` returns `{}` when the plugin is absent, hence the method
  * feature-check.
  */
@@ -46,14 +46,14 @@ async function resolveBackendKind(preferred) {
     // Native mobile: the platform speech recognizer (TalkMode) is the working STT
     // path and the only one that streams interim transcripts. Prefer it ahead of
     // the local-inference probe — on mobile that probe can report ready while the
-    // whisper assets are missing, then 502 at stop() with no recoverable fallback.
+    // local ASR assets are missing, then 502 at stop() with no recoverable fallback.
     if (isNativeTalkModeCaptureAvailable()) {
         return "talkmode";
     }
     // local-inference is the default elsewhere, but it needs BOTH the client
     // mic-capture primitives AND a server that can actually transcribe. Probe the
     // server's readiness (GET /api/asr/local-inference/status) so an unconfigured
-    // box (no whisper model / native adapter) degrades to browser SpeechRecognition
+    // box (no local ASR assets / native adapter) degrades to browser SpeechRecognition
     // instead of capturing audio it can only 502 on at stop().
     if ((preferred === "local-inference" || preferred === undefined) &&
         isLocalAsrCaptureSupported() &&

package/voice/voice-chat-playback.d.ts

@@ -2,7 +2,7 @@
  * Playback / TTS logic for voice chat — text processing, sentence splitting,
  * speech text extraction, and mouth animation helpers.
  */
-import { type SpeechSegmentKind } from "./voice-chat-types";
+import { type SpeechSegmentKind } from "./voice-chat-types.js";
 export declare function collapseWhitespace(input: string): string;
 export declare function normalizeCacheText(input: string): string;
 export declare function countSpeechTokens(input: string): number;

package/voice/voice-chat-types.d.ts

@@ -1,8 +1,8 @@
 /**
  * Types, constants, and config interfaces for the voice chat system.
  */
-import type { VoiceConfig, VoiceMode } from "../api/client";
-import type { Emotion } from "./emotion";
+import type { VoiceConfig, VoiceMode } from "../api/client.js";
+import type { Emotion } from "./emotion.js";
 export interface SpeechRecognitionInstance extends EventTarget {
     continuous: boolean;
     interimResults: boolean;

package/voice/voice-provider-defaults.d.ts

@@ -5,21 +5,24 @@
  * settings "advanced mode" picker design:
  *
  *   - Desktop running a local agent → on-device models
- *     (TTS: `local-inference` / OmniVoice, ASR: `local-inference` / Qwen3-ASR).
+ *     (TTS: `local-inference` / OmniVoice, ASR: `local-inference` / Gemma ASR).
  *   - Mobile running a local agent → on-device Kokoro TTS
  *     (TTS: `local-inference`; Kokoro is ~82M params and runs comfortably on
  *     phones — see `selectVoiceBackend({ mobile: true })`). ASR still routes
  *     to Eliza Cloud (`eliza-cloud`) because on-device speech recognition is
  *     heavier than TTS.
- *   - Cloud agents (any device) → always Eliza Cloud.
- *   - Remote-controller surfaces (UI hitting a remote API base) → Eliza
- *     Cloud, same rationale as cloud agents.
+ *   - Cloud agents (any device) → fast free Microsoft Edge neural TTS
+ *     (`edge`) for speech, Eliza Cloud (`eliza-cloud`) for ASR. ElevenLabs is
+ *     no longer a default — it is slow and key-gated; users can still opt into
+ *     it from the advanced voice picker.
+ *   - Remote-controller surfaces (UI hitting a remote API base) → same as
+ *     cloud agents (`edge` TTS, Eliza Cloud ASR).
  *
  * The picker is intentionally a pure function so it can be unit-tested
  * exhaustively. The React hook wrapper lives in
  * `hooks/useDefaultProviderPresets.ts`.
  */
-import type { AsrProvider, VoiceProvider } from "../api/client-types-config";
+import type { AsrProvider, VoiceProvider } from "../api/client-types-config.js";
 export type PresetPlatform = "desktop" | "mobile" | "web";
 /** Subset of the runtime-mode enum we care about for provider defaults. */
 export type PresetRuntimeMode = "local" | "local-only" | "cloud" | "remote";

package/voice/voice-provider-defaults.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"voice-provider-defaults.d.ts","sourceRoot":"","sources":["../../../../../src/voice/voice-provider-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE7E,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE1D,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5E,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,6BAA6B,GACnC,0BAA0B,CAuB5B"}
+{"version":3,"file":"voice-provider-defaults.d.ts","sourceRoot":"","sources":["../../../../../src/voice/voice-provider-defaults.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE7E,MAAM,MAAM,cAAc,GAAG,SAAS,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE1D,2EAA2E;AAC3E,MAAM,MAAM,iBAAiB,GAAG,OAAO,GAAG,YAAY,GAAG,OAAO,GAAG,QAAQ,CAAC;AAE5E,MAAM,WAAW,6BAA6B;IAC5C,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,iBAAiB,CAAC;CAChC;AAED,MAAM,WAAW,0BAA0B;IACzC,GAAG,EAAE,aAAa,CAAC;IACnB,GAAG,EAAE,WAAW,CAAC;CAClB;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,6BAA6B,GACnC,0BAA0B,CA2B5B"}