@elizaos/plugin-local-inference 2.0.0-beta.1 → 2.0.3-beta.2

package/src/services/voice/speaker-preset-cache.ts

@@ -0,0 +1,195 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import type { SpeakerPreset } from "./types";
+import {
+	type RefAudioTokens,
+	readVoicePresetFile,
+	type VoicePresetSeedPhrase,
+} from "./voice-preset-format";
+
+export interface PresetBundlePaths {
+	bundleRoot: string;
+	/** Relative path to the *default* voice preset inside the bundle. */
+	cacheRelPath?: string;
+}
+
+export interface LoadedPresetBundle {
+	preset: SpeakerPreset;
+	/** Phrase-cache seed entries parsed alongside the embedding. The engine
+	 *  bridge feeds these into a `PhraseCache.seed(...)` call before the
+	 *  scheduler is constructed. */
+	phrases: ReadonlyArray<VoicePresetSeedPhrase>;
+}
+
+export interface SpeakerPresetCacheOptions {
+	/**
+	 * Maximum number of distinct voices held in RAM at once. Speaker presets
+	 * are KB-scale (an embedding vector + the seed-phrase PCM), so the default
+	 * is generous; the bound exists so a connector that switches voices per
+	 * speaker (e.g. a Discord room with many users) does not grow unbounded.
+	 * On insert past the bound the least-recently-used voice is evicted.
+	 *
+	 * Defaults to 8 hot voices (R6 §1: "LRU 8 hot, mmap-backed").
+	 */
+	maxVoices?: number;
+}
+
+export const DEFAULT_VOICE_ID = "default";
+const DEFAULT_MAX_VOICES = 8;
+
+export const DEFAULT_VOICE_PRESET_REL_PATH = path.join(
+	"cache",
+	"voice-preset-default.bin",
+);
+
+/**
+ * Resolve the on-disk path of a voice preset inside a bundle. The default
+ * voice lives at `cache/voice-preset-default.bin`; additional voices ship as
+ * `cache/voice-preset-<voiceId>.bin`. Throws on a `voiceId` that is not a safe
+ * single path segment (no `/`, no `..`).
+ */
+export function voicePresetPath(bundleRoot: string, voiceId: string): string {
+	if (voiceId === DEFAULT_VOICE_ID) {
+		return path.join(bundleRoot, DEFAULT_VOICE_PRESET_REL_PATH);
+	}
+	if (!/^[A-Za-z0-9._-]+$/.test(voiceId) || voiceId.includes("..")) {
+		throw new Error(
+			`[voice] Invalid voiceId ${JSON.stringify(voiceId)} — must be a single path-safe segment.`,
+		);
+	}
+	return path.join(bundleRoot, "cache", `voice-preset-${voiceId}.bin`);
+}
+
+interface CacheEntry {
+	preset: SpeakerPreset;
+	phrases: ReadonlyArray<VoicePresetSeedPhrase>;
+}
+
+/**
+ * LRU cache of parsed speaker presets keyed by `voiceId`. Holds the speaker
+ * embedding, the raw preset bytes (for FFI handoff), and the phrase-cache seed
+ * list parsed from the preset file. Multi-voice: `load(bundleRoot, voiceId)`
+ * reads `cache/voice-preset-<voiceId>.bin` from the bundle on a miss.
+ *
+ * v2 preset fields (`refAudioTokens`, `refText`, `instruct`) are surfaced
+ * on the `SpeakerPreset` shape so the FFI bridge can pass them through to
+ * `ov_tts_params` without going through the legacy "instruct == voiceId"
+ * misreading.
+ */
+export class SpeakerPresetCache {
+	// `Map` preserves insertion order; we re-insert on access so the first key
+	// is always the least-recently-used.
+	private readonly entries = new Map<string, CacheEntry>();
+	private readonly maxVoices: number;
+
+	constructor(opts: SpeakerPresetCacheOptions = {}) {
+		this.maxVoices = Math.max(
+			1,
+			Math.floor(opts.maxVoices ?? DEFAULT_MAX_VOICES),
+		);
+	}
+
+	/**
+	 * Load the bundle's default voice preset (`cache/voice-preset-default.bin`,
+	 * or `paths.cacheRelPath` if overridden) and return both the speaker
+	 * embedding and the phrase-cache seed entries. Cached for subsequent
+	 * `get("default")` lookups (and marked most-recently-used).
+	 */
+	loadFromBundle(
+		paths: PresetBundlePaths,
+		voiceId = DEFAULT_VOICE_ID,
+	): LoadedPresetBundle {
+		const rel =
+			paths.cacheRelPath ??
+			(voiceId === DEFAULT_VOICE_ID
+				? DEFAULT_VOICE_PRESET_REL_PATH
+				: path.join("cache", `voice-preset-${voiceId}.bin`));
+		return this.loadFile(path.join(paths.bundleRoot, rel), voiceId);
+	}
+
+	/**
+	 * Load an arbitrary voice by id from a bundle root, reading
+	 * `cache/voice-preset-<voiceId>.bin` (or `cache/voice-preset-default.bin`
+	 * for `"default"`). Returns the cached entry on a hit (marked MRU).
+	 */
+	load(bundleRoot: string, voiceId: string): LoadedPresetBundle {
+		return this.loadFile(voicePresetPath(bundleRoot, voiceId), voiceId);
+	}
+
+	/** True if `voiceId` is currently resident in the cache. */
+	has(voiceId: string): boolean {
+		return this.entries.has(voiceId);
+	}
+
+	put(preset: SpeakerPreset): void {
+		const existing = this.entries.get(preset.voiceId);
+		this.entries.delete(preset.voiceId);
+		this.entries.set(preset.voiceId, {
+			preset,
+			phrases: existing?.phrases ?? [],
+		});
+		this.evictOverflow();
+	}
+
+	get(voiceId: string): SpeakerPreset | undefined {
+		const entry = this.entries.get(voiceId);
+		if (!entry) return undefined;
+		this.entries.delete(voiceId);
+		this.entries.set(voiceId, entry);
+		return entry.preset;
+	}
+
+	/** Seed entries previously loaded for a voice, if any (does not touch LRU order). */
+	getSeed(voiceId: string): ReadonlyArray<VoicePresetSeedPhrase> {
+		return this.entries.get(voiceId)?.phrases ?? [];
+	}
+
+	/** Number of voices currently resident. */
+	size(): number {
+		return this.entries.size;
+	}
+
+	/** Drop every cached preset. */
+	clear(): void {
+		this.entries.clear();
+	}
+
+	private loadFile(fullPath: string, voiceId: string): LoadedPresetBundle {
+		const cached = this.entries.get(voiceId);
+		if (cached) {
+			this.entries.delete(voiceId);
+			this.entries.set(voiceId, cached);
+			return { preset: cached.preset, phrases: cached.phrases };
+		}
+		if (!existsSync(fullPath)) {
+			throw new Error(
+				`[voice] Speaker preset for voice ${JSON.stringify(voiceId)} not found at ${fullPath}.`,
+			);
+		}
+		const bytes = new Uint8Array(readFileSync(fullPath));
+		const parsed = readVoicePresetFile(bytes);
+		const refTokens: RefAudioTokens = parsed.refAudioTokens;
+		const preset: SpeakerPreset = {
+			voiceId,
+			embedding: parsed.embedding,
+			bytes,
+			version: parsed.version,
+			refAudioTokens: refTokens,
+			refText: parsed.refText,
+			instruct: parsed.instruct,
+			metadata: parsed.metadata,
+		};
+		const entry: CacheEntry = { preset, phrases: parsed.phrases };
+		this.entries.set(voiceId, entry);
+		this.evictOverflow();
+		return { preset, phrases: parsed.phrases };
+	}
+
+	private evictOverflow(): void {
+		while (this.entries.size > this.maxVoices) {
+			const lru = this.entries.keys().next().value;
+			if (lru === undefined) return;
+			this.entries.delete(lru);
+		}
+	}
+}

package/src/services/voice/streaming-asr/streaming-pipeline-adapter.ts

@@ -0,0 +1,292 @@
+/**
+ * Streaming-ASR pipeline adapter (item A1 / W7).
+ *
+ * The base `VoicePipeline` in `voice/pipeline.ts` drives a `StreamingTranscriber`
+ * as a batch: it pushes the WHOLE VAD-gated utterance buffer in a single
+ * `feed()` call, awaits `flush()`, and only then splits the final transcript
+ * into tokens for the drafter/verifier loop. That works for the fused
+ * batch decoder, but it leaves the biggest
+ * H2 UX seam (incremental partials → planner / barge-in word-confirm /
+ * speculative-on-pause) untapped when the fused build is in streaming mode.
+ *
+ * Rather than rewrite `pipeline.ts` (the Phase 0/1 agent owns it), this
+ * module is a small WRAPPER the engine bridge can use to deliver PCM
+ * chunks to a `StreamingTranscriber` as they arrive from the mic / VAD,
+ * surface every `partial` event to the turn controller via `onPartial`,
+ * and only finalize on `speech-end`. Behind a flag — when the fused
+ * library advertises `asrStreamSupported() === false` or the flag is off
+ * the caller keeps using `VoicePipeline.transcribeAll` exactly as today.
+ *
+ * Integration point (documented for the Phase 0/1 agent so they can wire
+ * it without merge friction):
+ *
+ *   1. `EngineVoiceBridge` decides whether streaming is available via
+ *      `pickStreamingMode({ ffi, asrBundlePresent, flag })`. When the
+ *      mode is `"streaming"`, the bridge constructs `StreamingAsrFeeder`
+ *      once per turn (passing the same transcriber that would have been
+ *      handed to `VoicePipeline`) and routes mic PCM frames through
+ *      `feeder.feedFrame(frame)` instead of buffering them.
+ *   2. The feeder forwards every transcriber `partial` event to
+ *      `onPartial(update)`. When VAD reports `speech-end` the caller
+ *      calls `await feeder.finalize()`; the returned `TranscriptUpdate`
+ *      is the final and is used to seed the drafter/verifier loop exactly
+ *      as before (`splitTranscriptToTokens(final.partial, 0, final.tokens)`).
+ *   3. The batch path (`VoicePipeline.transcribeAll`) is unchanged for
+ *      every other adapter — there is no fork in `pipeline.ts` itself.
+ *
+ * This file is intentionally small and side-effect-free so it can land
+ * during the merge window without touching files other agents own.
+ */
+
+import { splitTranscriptToTokens } from "../pipeline";
+import type {
+	PcmFrame,
+	StreamingTranscriber,
+	TextToken,
+	TranscriptUpdate,
+} from "../types";
+
+/* ==================================================================== *
+ * LocalAgreementBuffer — word-level streaming-ASR partial stabilizer.
+ *
+ * Streaming ASR emits a fresh word-sequence hypothesis on every audio
+ * frame. Individual words near the end of the hypothesis can change
+ * across frames ("sat" → "cap" → "sat") before settling. This buffer
+ * applies LocalAgreement-n (n=2 default) at the word level: a word is
+ * emitted to downstream only when it appears at the same position in n
+ * consecutive hypotheses. The committed stable prefix is monotonically
+ * non-decreasing — once a word is committed it is never retracted.
+ *
+ * Word-level (not character-level): suited for the VAD pipeline adapter
+ * where downstream consumers (drafter, verifier) operate on word tokens.
+ * For the character-level prefix variant, see `partial-stabilizer.ts`.
+ * ==================================================================== */
+
+/**
+ * LocalAgreement-n word-level partial stabilizer.
+ *
+ * Usage:
+ *   const buf = new LocalAgreementBuffer();
+ *   const stable = buf.stable(["hello", "there", "world"]);
+ *   // → [] on first call (need n=2 consecutive identical prefix)
+ *   const stable2 = buf.stable(["hello", "there", "how"]);
+ *   // → ["hello", "there"] (matched across two consecutive hypotheses)
+ */
+export class LocalAgreementBuffer {
+	private readonly n: number;
+	/** Rolling window of the last `n` hypotheses, oldest first. */
+	private window: string[][] = [];
+	/** Monotonically growing committed word list. */
+	private committed: string[] = [];
+
+	constructor(n = 2) {
+		if (!Number.isFinite(n) || n < 1) {
+			throw new Error(
+				`[LocalAgreementBuffer] n must be a finite integer >= 1; got ${String(n)}`,
+			);
+		}
+		this.n = Math.floor(n);
+	}
+
+	/**
+	 * Feed the latest word-level hypothesis. Returns the stable committed
+	 * prefix — the longest leading word sequence that has appeared
+	 * identically in `n` consecutive calls. Monotonically non-decreasing.
+	 *
+	 * A rolling window of the last `n` hypotheses is maintained. Once the
+	 * window is full, the agreed prefix is the intersection across all `n`
+	 * entries — word i is in the agreed prefix only if it is identical in
+	 * every hypothesis in the window.
+	 */
+	stable(current: string[]): string[] {
+		this.window.push(current);
+		if (this.window.length > this.n) {
+			this.window.shift();
+		}
+		// Need a full window of `n` hypotheses before any word can be agreed.
+		if (this.window.length < this.n) {
+			return this.committed;
+		}
+		// Intersect: the agreed prefix is the longest common leading prefix
+		// across all entries in the window.
+		const first = this.window[0];
+		if (!first) {
+			throw new Error("hypothesis window unexpectedly empty");
+		}
+		let agreedLen = first.length;
+		for (let i = 1; i < this.window.length; i++) {
+			const h = this.window[i];
+			if (!h) {
+				throw new Error(`missing hypothesis at index ${i}`);
+			}
+			let matchLen = 0;
+			const limit = Math.min(agreedLen, h.length);
+			for (let j = 0; j < limit; j++) {
+				if (first[j] === h[j]) matchLen++;
+				else break;
+			}
+			agreedLen = matchLen;
+			if (agreedLen === 0) break;
+		}
+		// Extend committed if the new agreement is longer.
+		if (agreedLen > this.committed.length) {
+			this.committed = first.slice(0, agreedLen);
+		}
+		return this.committed;
+	}
+
+	/** Clear all state. Call at utterance boundaries. */
+	reset(): void {
+		this.window = [];
+		this.committed = [];
+	}
+
+	/** The current committed stable word list (read-only view). */
+	getCommitted(): string[] {
+		return this.committed;
+	}
+}
+
+/** Available transcription drive modes. */
+export type StreamingPipelineMode = "streaming" | "batch";
+
+export interface PickStreamingModeArgs {
+	/** True only when the loaded fused library advertises a working streaming decoder. */
+	ffiSupportsStreaming: boolean;
+	/** True only when the bundled ASR model is present on disk. */
+	asrBundlePresent: boolean;
+	/**
+	 * Feature flag — defaults to FALSE so the streaming path stays opt-in
+	 * until the Phase 0/1 partial-stabilizer wiring lands. Once that lands
+	 * the engine bridge flips this default to true.
+	 */
+	enableStreaming: boolean;
+}
+
+/**
+ * Choose the transcription drive mode. Streaming is selected only when:
+ *   - the loaded fused library advertises a working streaming decoder
+ *     (`asr_stream_supported() === 1`), AND
+ *   - the bundled ASR model is present, AND
+ *   - the engine bridge has opted in via `enableStreaming`.
+ *
+ * Any other combination falls back to the existing batch path
+ * (`VoicePipeline.transcribeAll`).
+ */
+export function pickStreamingMode(
+	args: PickStreamingModeArgs,
+): StreamingPipelineMode {
+	if (!args.enableStreaming) return "batch";
+	if (!args.ffiSupportsStreaming) return "batch";
+	if (!args.asrBundlePresent) return "batch";
+	return "streaming";
+}
+
+export interface StreamingAsrFeederEvents {
+	/**
+	 * Called for every transcriber `partial` event the feeder observes
+	 * BEFORE the segment is finalized. Includes the running `partial`
+	 * text, `isFinal: false`, and (when the fused build supplied them)
+	 * the shared text-model token ids.
+	 */
+	onPartial?(update: TranscriptUpdate): void;
+	/**
+	 * Called the first time ≥1 real word is recognized in the segment.
+	 * Wired into the turn controller's word-confirm gate so the agent
+	 * only barge-in-cancels on real speech, not blips.
+	 */
+	onWords?(words: ReadonlyArray<string>): void;
+	/**
+	 * Called once, after `finalize()` returns, with the final transcript
+	 * split into contiguous text tokens (`splitTranscriptToTokens`). The
+	 * batch path delivers the same shape via `transcribeAll`, so the
+	 * downstream drafter/verifier loop sees an identical signal.
+	 */
+	onFinalTokens?(
+		tokens: ReadonlyArray<TextToken>,
+		final: TranscriptUpdate,
+	): void;
+}
+
+/**
+ * Drives a `StreamingTranscriber` chunk-by-chunk on behalf of the engine
+ * bridge / turn controller. One instance per active speech segment;
+ * `finalize()` returns the final transcript and the feeder is disposed.
+ *
+ * Construction takes a `StreamingTranscriber` (already constructed via
+ * `createStreamingTranscriber` with the same options used for batch).
+ * The feeder does NOT own the transcriber's lifecycle — disposal still
+ * runs through the engine bridge so the same path is used when the
+ * batch fallback is taken.
+ */
+export class StreamingAsrFeeder {
+	private readonly transcriber: StreamingTranscriber;
+	private readonly events: StreamingAsrFeederEvents;
+	private latestPartial: TranscriptUpdate | null = null;
+	private finalized = false;
+	private unsubscribe: (() => void) | null = null;
+
+	constructor(args: {
+		transcriber: StreamingTranscriber;
+		events?: StreamingAsrFeederEvents;
+	}) {
+		this.transcriber = args.transcriber;
+		this.events = args.events ?? {};
+		this.unsubscribe = this.transcriber.on((event) => {
+			switch (event.kind) {
+				case "partial":
+					this.latestPartial = event.update;
+					this.events.onPartial?.(event.update);
+					break;
+				case "words":
+					this.events.onWords?.(event.words);
+					break;
+				case "final":
+					// Final events are surfaced via `finalize()`'s return value so
+					// the caller has a single point of truth. We do not re-emit
+					// them here.
+					break;
+			}
+		});
+	}
+
+	/**
+	 * Feed one PCM frame as it arrives from the mic / connector. Drops
+	 * frames received after `finalize()` (the segment is over).
+	 */
+	feedFrame(frame: PcmFrame): void {
+		if (this.finalized) return;
+		this.transcriber.feed(frame);
+	}
+
+	/**
+	 * Force-finalize on `speech-end`. Resolves with the final transcript
+	 * and emits `onFinalTokens` so the caller can seed the drafter /
+	 * verifier loop without re-running the surface split itself.
+	 *
+	 * Calling `finalize()` twice is a hard error — the segment is over.
+	 */
+	async finalize(): Promise<TranscriptUpdate> {
+		if (this.finalized) {
+			throw new Error(
+				"[streaming-asr] finalize() called twice on the same feeder",
+			);
+		}
+		this.finalized = true;
+		const final = await this.transcriber.flush();
+		const tokens = splitTranscriptToTokens(final.partial, 0, final.tokens);
+		this.events.onFinalTokens?.(tokens, final);
+		return final;
+	}
+
+	/** The most recent `partial` snapshot observed, or `null` until the first decode lands. */
+	getLatestPartial(): TranscriptUpdate | null {
+		return this.latestPartial;
+	}
+
+	/** Detach the transcriber subscription. Does NOT dispose the transcriber itself. */
+	dispose(): void {
+		this.unsubscribe?.();
+		this.unsubscribe = null;
+	}
+}

package/src/services/voice/system-audio-sink.d.ts

@@ -0,0 +1,73 @@
+/**
+ * System audio sinks for the interactive voice harness.
+ *
+ * The voice scheduler writes synthesized PCM (`Float32Array` mono in
+ * [-1, 1] at the bridge sample rate) into an {@link AudioSink}. For tests
+ * and headless runs `InMemoryAudioSink` (in `./ring-buffer`) captures the
+ * samples; for an interactive session the harness needs the audio to
+ * actually come out of the speakers.
+ *
+ * `SystemAudioSink` shells out to a long-lived player that reads raw 16-bit
+ * signed-LE PCM on stdin. Per-platform selection (priority order):
+ *   - Linux:   `aplay` (alsa-utils), else `paplay` (PulseAudio), else
+ *              `play`/`sox` (sox), else `ffplay` (ffmpeg).
+ *   - macOS:   `play`/`sox` (sox), else `ffplay` (ffmpeg). `afplay` needs a
+ *              file (no stdin) so it cannot be used for streaming.
+ *   - Windows: `ffplay` (ffmpeg), else `play`/`sox` if installed. PowerShell's
+ *              `Media.SoundPlayer` also needs a file, not a stream, so it's not
+ *              used here — the renderer's `AudioContext` path (feeding nothing
+ *              here; the renderer plays directly) is the no-ffmpeg route.
+ * If no player is on `PATH`, `available()` returns false and the harness
+ * falls back to `WavFileAudioSink` (writes a rolling WAV) — never silence.
+ *
+ * `WavFileAudioSink` accumulates everything written and serializes a
+ * single mono PCM16 WAV on `finalize()` — used by `--no-audio` and as the
+ * no-player fallback.
+ */
+import type { AudioSink } from "./types";
+/**
+ * Exported view of {@link resolvePlayer} for the cross-platform preflight
+ * (`voice:interactive --platform-report`). Returns the bare program name
+ * (no args) the host would stream synthesized audio to, or `null`.
+ */
+export declare function resolveSystemPlayerName(sampleRate?: number): string | null;
+export interface SystemAudioSinkOptions {
+    sampleRate: number;
+}
+export declare class SystemAudioSink implements AudioSink {
+    private readonly sampleRate;
+    private readonly playerSpec;
+    private proc;
+    private buffered;
+    constructor(opts: SystemAudioSinkOptions);
+    available(): boolean;
+    player(): string;
+    private ensureProc;
+    write(pcm: Float32Array, _sampleRate: number): void;
+    drain(): void;
+    bufferedSamples(): number;
+    /** Flush + close the player. Idempotent. */
+    dispose(): Promise<void>;
+}
+export interface WavFileAudioSinkOptions {
+    sampleRate: number;
+    filePath: string;
+}
+/**
+ * Accumulates all written PCM and serializes a single mono PCM16 WAV on
+ * {@link finalize}. Used by `--no-audio` and as the no-player fallback so
+ * a headless run still produces an inspectable artifact (never silence).
+ */
+export declare class WavFileAudioSink implements AudioSink {
+    private readonly sampleRate;
+    private readonly filePath;
+    private readonly chunks;
+    private buffered;
+    constructor(opts: WavFileAudioSinkOptions);
+    write(pcm: Float32Array, _sampleRate: number): void;
+    drain(): void;
+    bufferedSamples(): number;
+    totalSamples(): number;
+    finalize(): Promise<string>;
+}
+//# sourceMappingURL=system-audio-sink.d.ts.map

package/src/services/voice/system-audio-sink.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-audio-sink.d.ts","sourceRoot":"","sources":["system-audio-sink.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAQH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAoIzC;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,SAAS,GAAG,MAAM,GAAG,IAAI,CAG1E;AAED,MAAM,WAAW,sBAAsB;IACtC,UAAU,EAAE,MAAM,CAAC;CACnB;AAWD,qBAAa,eAAgB,YAAW,SAAS;IAChD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAyC;IACpE,OAAO,CAAC,IAAI,CAAiC;IAC7C,OAAO,CAAC,QAAQ,CAAK;gBAET,IAAI,EAAE,sBAAsB;IAKxC,SAAS,IAAI,OAAO;IAIpB,MAAM,IAAI,MAAM;IAIhB,OAAO,CAAC,UAAU;IAmBlB,KAAK,CAAC,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAUnD,KAAK,IAAI,IAAI;IAmBb,eAAe,IAAI,MAAM;IAIzB,4CAA4C;IACtC,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;CA6B9B;AAED,MAAM,WAAW,uBAAuB;IACvC,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CACjB;AAED;;;;GAIG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IACjD,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsB;IAC7C,OAAO,CAAC,QAAQ,CAAK;gBAET,IAAI,EAAE,uBAAuB;IAKzC,KAAK,CAAC,GAAG,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAKnD,KAAK,IAAI,IAAI;IAMb,eAAe,IAAI,MAAM;IAIzB,YAAY,IAAI,MAAM;IAMhB,QAAQ,IAAI,OAAO,CAAC,MAAM,CAAC;CAgCjC"}

package/src/services/voice/system-audio-sink.test.ts

@@ -0,0 +1,29 @@
+import { mkdtempSync, readFileSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { WavFileAudioSink } from "./system-audio-sink";
+
+describe("WavFileAudioSink", () => {
+	it("drain resets buffered samples without dropping artifact chunks", async () => {
+		const dir = mkdtempSync(path.join(tmpdir(), "eliza-audio-sink-"));
+		const filePath = path.join(dir, "out.wav");
+		try {
+			const sink = new WavFileAudioSink({ sampleRate: 24_000, filePath });
+			sink.write(new Float32Array([0.1, 0.2, 0.3]), 24_000);
+			expect(sink.bufferedSamples()).toBe(3);
+
+			sink.drain();
+			expect(sink.bufferedSamples()).toBe(0);
+			await sink.finalize();
+
+			const wav = readFileSync(filePath);
+			expect(wav.subarray(0, 4).toString("ascii")).toBe("RIFF");
+			expect(wav.subarray(8, 12).toString("ascii")).toBe("WAVE");
+			expect(wav.readUInt32LE(40)).toBe(6);
+			expect(wav.length).toBe(50);
+		} finally {
+			rmSync(dir, { recursive: true, force: true });
+		}
+	});
+});