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

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

@@ -0,0 +1,366 @@
+/**
+ * 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 ChildProcessByStdio, spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import process from "node:process";
+import type { Writable } from "node:stream";
+import type { AudioSink } from "./types";
+
+function which(bin: string): string | null {
+	const pathEnv = process.env.PATH ?? "";
+	const exts =
+		process.platform === "win32" ? [".exe", ".cmd", ".bat", ""] : [""];
+	for (const dir of pathEnv.split(path.delimiter)) {
+		for (const ext of exts) {
+			const candidate = path.join(dir, bin + ext);
+			if (existsSync(candidate)) return candidate;
+		}
+	}
+	return null;
+}
+
+function floatToPcm16(pcm: Float32Array): Buffer {
+	const out = Buffer.allocUnsafe(pcm.length * 2);
+	for (let i = 0; i < pcm.length; i++) {
+		let s = pcm[i];
+		if (s > 1) s = 1;
+		else if (s < -1) s = -1;
+		out.writeInt16LE((s * 0x7fff) | 0, i * 2);
+	}
+	return out;
+}
+
+function soxRawArgs(sampleRate: number): string[] {
+	return [
+		"-q",
+		"-t",
+		"raw",
+		"-r",
+		String(sampleRate),
+		"-e",
+		"signed",
+		"-b",
+		"16",
+		"-c",
+		"1",
+		"-",
+	];
+}
+
+function ffplayRawArgs(sampleRate: number): string[] {
+	// ffplay reads raw PCM with -f s16le; -nodisp suppresses the window,
+	// -autoexit quits at EOF, -i - reads stdin.
+	return [
+		"-loglevel",
+		"error",
+		"-nodisp",
+		"-autoexit",
+		"-f",
+		"s16le",
+		"-ar",
+		String(sampleRate),
+		"-ac",
+		"1",
+		"-i",
+		"-",
+	];
+}
+
+/** Pick a CLI player that reads raw PCM16-LE on stdin, for the host platform. */
+function resolvePlayer(
+	sampleRate: number,
+): { bin: string; args: string[] } | null {
+	if (process.platform === "linux") {
+		const aplay = which("aplay");
+		if (aplay) {
+			return {
+				bin: aplay,
+				args: [
+					"-q",
+					"-f",
+					"S16_LE",
+					"-c",
+					"1",
+					"-r",
+					String(sampleRate),
+					"-t",
+					"raw",
+					"-",
+				],
+			};
+		}
+		const paplay = which("paplay");
+		if (paplay) {
+			return {
+				bin: paplay,
+				args: [
+					"--raw",
+					`--format=s16le`,
+					"--channels=1",
+					`--rate=${sampleRate}`,
+				],
+			};
+		}
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		return null;
+	}
+	if (process.platform === "darwin") {
+		// `afplay` needs a file (no stdin), so it can't stream — use sox/ffplay.
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		return null;
+	}
+	if (process.platform === "win32") {
+		const ffplay = which("ffplay");
+		if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+		const play = which("play");
+		if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+		const sox = which("sox");
+		if (sox) return { bin: sox, args: [...soxRawArgs(sampleRate), "-d"] };
+		return null;
+	}
+	// Other (BSD, etc.) — best-effort sox/ffplay.
+	const play = which("play");
+	if (play) return { bin: play, args: soxRawArgs(sampleRate) };
+	const ffplay = which("ffplay");
+	if (ffplay) return { bin: ffplay, args: ffplayRawArgs(sampleRate) };
+	return null;
+}
+
+/**
+ * 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 function resolveSystemPlayerName(sampleRate = 24_000): string | null {
+	const spec = resolvePlayer(sampleRate);
+	return spec ? path.basename(spec.bin) : null;
+}
+
+export interface SystemAudioSinkOptions {
+	sampleRate: number;
+}
+
+/**
+ * Streams synthesized PCM to a long-lived CLI player (`aplay` / `paplay` /
+ * sox `play`). `write()` is non-blocking — PCM is buffered into the
+ * player's stdin pipe. `drain()` is a barge-in hook: it kills the current
+ * player so queued audio stops within a tick, then a fresh player is
+ * spawned lazily on the next `write()`.
+ */
+type StdinPipeProcess = ChildProcessByStdio<Writable, null, null>;
+
+export class SystemAudioSink implements AudioSink {
+	private readonly sampleRate: number;
+	private readonly playerSpec: { bin: string; args: string[] } | null;
+	private proc: StdinPipeProcess | null = null;
+	private buffered = 0;
+
+	constructor(opts: SystemAudioSinkOptions) {
+		this.sampleRate = opts.sampleRate;
+		this.playerSpec = resolvePlayer(opts.sampleRate);
+	}
+
+	available(): boolean {
+		return this.playerSpec !== null;
+	}
+
+	player(): string {
+		return this.playerSpec ? path.basename(this.playerSpec.bin) : "(none)";
+	}
+
+	private ensureProc(): StdinPipeProcess | null {
+		if (!this.playerSpec) return null;
+		if (this.proc && !this.proc.killed && this.proc.exitCode === null)
+			return this.proc;
+		const child = spawn(this.playerSpec.bin, this.playerSpec.args, {
+			stdio: ["pipe", "ignore", "ignore"] as const,
+		});
+		child.on("error", () => {
+			// Player vanished mid-stream — drop it; next write retries.
+			if (this.proc === child) this.proc = null;
+		});
+		child.on("exit", () => {
+			if (this.proc === child) this.proc = null;
+			this.buffered = 0;
+		});
+		this.proc = child;
+		return child;
+	}
+
+	write(pcm: Float32Array, _sampleRate: number): void {
+		const child = this.ensureProc();
+		if (!child?.stdin.writable) return;
+		const bytes = floatToPcm16(pcm);
+		this.buffered += pcm.length;
+		child.stdin.write(bytes, () => {
+			this.buffered = Math.max(0, this.buffered - pcm.length);
+		});
+	}
+
+	drain(): void {
+		// Barge-in: stop the player immediately. The next write spawns a fresh
+		// one so the new turn's audio isn't queued behind cancelled audio.
+		if (this.proc) {
+			try {
+				this.proc.stdin.destroy();
+			} catch {
+				/* ignore */
+			}
+			try {
+				this.proc.kill("SIGKILL");
+			} catch {
+				/* ignore */
+			}
+			this.proc = null;
+		}
+		this.buffered = 0;
+	}
+
+	bufferedSamples(): number {
+		return this.buffered;
+	}
+
+	/** Flush + close the player. Idempotent. */
+	async dispose(): Promise<void> {
+		const child = this.proc;
+		this.proc = null;
+		if (!child) return;
+		await new Promise<void>((resolve) => {
+			let done = false;
+			const finish = () => {
+				if (done) return;
+				done = true;
+				resolve();
+			};
+			child.on("exit", finish);
+			child.on("error", finish);
+			try {
+				child.stdin.end();
+			} catch {
+				finish();
+			}
+			// Don't hang on a stuck player.
+			setTimeout(() => {
+				try {
+					child.kill("SIGKILL");
+				} catch {
+					/* ignore */
+				}
+				finish();
+			}, 1500);
+		});
+	}
+}
+
+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 class WavFileAudioSink implements AudioSink {
+	private readonly sampleRate: number;
+	private readonly filePath: string;
+	private readonly chunks: Float32Array[] = [];
+	private buffered = 0;
+
+	constructor(opts: WavFileAudioSinkOptions) {
+		this.sampleRate = opts.sampleRate;
+		this.filePath = opts.filePath;
+	}
+
+	write(pcm: Float32Array, _sampleRate: number): void {
+		this.chunks.push(pcm.slice());
+		this.buffered += pcm.length;
+	}
+
+	drain(): void {
+		// The WAV sink keeps everything (it's an artifact, not a live stream),
+		// so `drain()` only resets the "buffered" counter the scheduler reads.
+		this.buffered = 0;
+	}
+
+	bufferedSamples(): number {
+		return this.buffered;
+	}
+
+	totalSamples(): number {
+		let n = 0;
+		for (const c of this.chunks) n += c.length;
+		return n;
+	}
+
+	async finalize(): Promise<string> {
+		const total = this.totalSamples();
+		const dataBytes = total * 2;
+		const header = Buffer.allocUnsafe(44);
+		header.write("RIFF", 0, "ascii");
+		header.writeUInt32LE(36 + dataBytes, 4);
+		header.write("WAVE", 8, "ascii");
+		header.write("fmt ", 12, "ascii");
+		header.writeUInt32LE(16, 16); // PCM fmt chunk size
+		header.writeUInt16LE(1, 20); // PCM
+		header.writeUInt16LE(1, 22); // mono
+		header.writeUInt32LE(this.sampleRate, 24);
+		header.writeUInt32LE(this.sampleRate * 2, 28); // byte rate
+		header.writeUInt16LE(2, 32); // block align
+		header.writeUInt16LE(16, 34); // bits per sample
+		header.write("data", 36, "ascii");
+		header.writeUInt32LE(dataBytes, 40);
+		const body = Buffer.allocUnsafe(dataBytes);
+		let off = 0;
+		for (const chunk of this.chunks) {
+			for (let i = 0; i < chunk.length; i++) {
+				let s = chunk[i];
+				if (s > 1) s = 1;
+				else if (s < -1) s = -1;
+				body.writeInt16LE((s * 0x7fff) | 0, off);
+				off += 2;
+			}
+		}
+		await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+		await fs.writeFile(this.filePath, Buffer.concat([header, body]));
+		return this.filePath;
+	}
+}

package/src/services/voice/transcriber.d.ts

@@ -0,0 +1,244 @@
+/**
+ * Streaming ASR adapters for the local voice pipeline.
+ *
+ * Implements the `StreamingTranscriber` contract from `voice/types.ts`:
+ * PCM frames in (`feed`), running partial-transcript events out, `flush()`
+ * to force-finalize on `speech-end`. Two adapters, resolved in priority
+ * order by `createStreamingTranscriber()` — both backed by the single fused
+ * `libelizainference` build (the SOLE on-device ASR runtime):
+ *
+ *   1. `FfiStreamingTranscriber` — the FINAL path. Drives the fused
+ *      `libelizainference` streaming ASR ABI (`eliza_inference_asr_stream_*`,
+ *      ABI v2 — declared in `packages/app-core/scripts/omnivoice-fuse/ffi.h`,
+ *      bound in `voice/ffi-bindings.ts`). The C side is W7's job; until the
+ *      real fused build advertises streaming ASR the binding's `mmap`/`asr`
+ *      calls return `ELIZA_ERR_NOT_IMPLEMENTED`, which surfaces as a thrown
+ *      error here. Selected only when `ffi.asrStreamSupported()` is true.
+ *
+ *   2. `FfiBatchTranscriber` — the contract-clean INTERIM path. Runs the
+ *      fused build's *batch* decoder (`eliza_inference_asr_transcribe`, ABI
+ *      v1) over a sliding window with overlap, so each call covers ≤ ~6–7 s
+ *      of audio — incremental, not "buffer the whole utterance, one giant
+ *      decode". It lives inside the single shipped llama.cpp/GGML build and
+ *      emits the Qwen2-BPE text-vocab (AGENTS.md §1/§4), so it does not
+ *      vendor a second ggml or introduce a tokenizer-family mismatch.
+ *      Selected whenever a `libelizainference` handle + bundled ASR model are
+ *      present (which is always true when the fused build is loaded).
+ *
+ * If no fused ASR backend can be resolved, `createStreamingTranscriber()`
+ * throws `AsrUnavailableError` — a real failure, never a silent
+ * empty-transcript degrade and never a fall back to a second ASR runtime
+ * (AGENTS.md §3 + §9).
+ */
+import type { ElizaInferenceContextHandle, ElizaInferenceFfi } from "./ffi-bindings";
+import type { PcmFrame, StreamingTranscriber, TranscriberEventListener, TranscriptUpdate, VadEventSource, VoiceInputSource, VoiceSpeaker, VoiceTurnMetadata } from "./types";
+/** The local voice runtime resamples mic input to 16 kHz mono for ASR. */
+export declare const ASR_SAMPLE_RATE = 16000;
+/**
+ * Raised when no ASR backend can be resolved. Distinct error class so the
+ * caller (engine, `TRANSCRIPTION` model handler) can surface "ASR is not
+ * installed" with an actionable message rather than treating an empty
+ * string as a successful transcription.
+ */
+export declare class AsrUnavailableError extends Error {
+    constructor(message: string);
+}
+export type AsrBackendPreference = "auto" | "fused" | "ffi-batch";
+export declare function normalizeAsrBackendPreference(value: string | null | undefined): AsrBackendPreference | null;
+export declare function readAsrBackendPreferenceFromEnv(env?: NodeJS.ProcessEnv): AsrBackendPreference | null;
+/**
+ * Linear-interpolation resample of mono fp32 PCM. Used to coerce mic
+ * frames (commonly 16 / 24 / 48 kHz) to the ASR rate. Not a polyphase
+ * filter — adequate for speech ASR; the fused build does its own
+ * resampling so this is interim-batch only.
+ */
+export declare function resampleLinear(pcm: Float32Array, fromRate: number, toRate: number): Float32Array;
+/**
+ * Base implementing the boilerplate every adapter shares: listener
+ * fan-out, the `words`-once-per-segment latch, and (optional) VAD-event
+ * gating. Subclasses implement `onFrame` / `onFlush` / `onDispose` and
+ * call `emitPartial` / `emitFinal`.
+ */
+export declare abstract class BaseStreamingTranscriber implements StreamingTranscriber {
+    private readonly listeners;
+    private metadata;
+    /** True between `speech-start`/first-frame and the next `flush()`. */
+    protected segmentOpen: boolean;
+    /** Latched once `words` is emitted for the current segment. */
+    private wordsEmitted;
+    /** When set, frames are only forwarded while the VAD is in an active speech window. */
+    private vadActive;
+    private readonly vadPrerollFrames;
+    private vadUnsub;
+    private disposed;
+    constructor(vad?: VadEventSource, metadata?: TranscriptMetadataDefaults);
+    on(listener: TranscriberEventListener): () => void;
+    /**
+     * Update the metadata defaults that `withMetadata()` merges into every
+     * partial / final emission. The voice pipeline calls this once the
+     * async speaker-ID / diarizer lookup resolves, so the speaker /
+     * segments are attached to the rest of the turn without buffering all
+     * partials for the lookup.
+     */
+    setMetadataDefaults(metadata: TranscriptMetadataDefaults): void;
+    feed(frame: PcmFrame): void;
+    flush(): Promise<TranscriptUpdate>;
+    dispose(): void;
+    /** Subclass hook: a (VAD-gated) PCM frame for the current speech segment. */
+    protected abstract onFrame(frame: PcmFrame): void;
+    /** Subclass hook: drain buffered audio, run a final decode, return the final transcript. */
+    protected abstract onFlush(): Promise<TranscriptUpdate>;
+    /** Subclass hook: release native resources. */
+    protected abstract onDispose(): void;
+    private rememberVadPreroll;
+    private drainVadPreroll;
+    /** Emit a running-partial event and (the first time it has words) a `words` event. */
+    protected emitPartial(update: TranscriptUpdate): void;
+    private withMetadata;
+    private emit;
+    private onVadEvent;
+}
+export interface TranscriptMetadataDefaults {
+    source?: VoiceInputSource;
+    speaker?: VoiceSpeaker;
+    turn?: VoiceTurnMetadata;
+}
+/**
+ * True when the loaded fused library has a working streaming ASR decoder
+ * (not just the v2 symbols — an ABI-only build exports them but `asrStreamSupported`
+ * returns false). This is the gate `createStreamingTranscriber` uses to
+ * pick the fused path over the fused-batch interim adapter.
+ */
+export declare function ffiSupportsStreamingAsr(ffi: ElizaInferenceFfi | null | undefined): boolean;
+/**
+ * `StreamingTranscriber` over the fused `libelizainference` streaming ASR
+ * ABI. Each `feed()` forwards the (resampled) PCM into `asrStreamFeed`;
+ * after a feed it reads the running partial via `asrStreamPartial`.
+ * `flush()` calls `asrStreamFinish` then re-opens a fresh stream for the
+ * next segment. Token ids, when the library returns them, are surfaced in
+ * `TranscriptUpdate.tokens` — the fused build shares the text vocabulary
+ * (AGENTS.md §1) so they feed STT-finish token injection directly.
+ *
+ * The C side is owned by W7; until the fused build implements these
+ * symbols every call throws (the binding maps `ELIZA_ERR_NOT_IMPLEMENTED`
+ * to a `VoiceLifecycleError`). That is intentional — no fake transcripts.
+ */
+export declare class FfiStreamingTranscriber extends BaseStreamingTranscriber {
+    private readonly ffi;
+    private readonly getContext;
+    /** Token count to ask the library for per partial; 0 = don't request tokens. */
+    private readonly maxTokens;
+    private stream;
+    constructor(args: {
+        ffi: ElizaInferenceFfi;
+        getContext: () => ElizaInferenceContextHandle;
+        vad?: VadEventSource;
+        metadata?: TranscriptMetadataDefaults;
+        source?: VoiceInputSource;
+        /** Cap on token ids read back per transcript snapshot. Default 256. */
+        maxTokens?: number;
+    });
+    private ensureStream;
+    protected onFrame(frame: PcmFrame): void;
+    protected onFlush(): Promise<TranscriptUpdate>;
+    protected onDispose(): void;
+}
+export interface FfiBatchTranscriberOptions {
+    ffi: ElizaInferenceFfi;
+    getContext: () => ElizaInferenceContextHandle;
+    vad?: VadEventSource;
+    metadata?: TranscriptMetadataDefaults;
+    source?: VoiceInputSource;
+    /** Sliding-window length, seconds. Each batch decode covers ≤ this + overlap. Default 6.0. */
+    windowSeconds?: number;
+    /** Trailing overlap kept when committing a prefix chunk, seconds. Default 1.0. */
+    overlapSeconds?: number;
+    /** Minimum new audio (seconds) accumulated before the next decode pass. Default 1.2. */
+    stepSeconds?: number;
+}
+/**
+ * Interim streaming-ASR adapter over the fused `libelizainference` **batch**
+ * decoder (`eliza_inference_asr_transcribe`, ABI v1). The fused build's true
+ * streaming decoder (`eliza_inference_asr_stream_*`, ABI v2) reports unsupported
+ * until its runtime lands; this adapter is the contract-clean interim — it runs
+ * inside the one shipped llama.cpp/GGML build and emits
+ * Qwen2-BPE token-vocab text (AGENTS.md §1, §4), so no second ggml is
+ * vendored and no tokenizer-family mismatch is introduced.
+ *
+ * It runs a *windowed re-transcription with overlap* strategy: a prefix older
+ * than `windowSeconds` is committed (decoded once, in window-sized chunks
+ * with `overlapSeconds` carry-over) and only the tail window is re-decoded
+ * each step. So each `asr_transcribe` call is bounded by `windowSeconds +
+ * overlap` of audio (≈6–7 s) — incremental, not "buffer the whole utterance,
+ * run one giant batch decode". Decodes run serially on the shared ASR mutex
+ * (the fused context's ASR region is single-threaded).
+ *
+ * Requires `ffi.mmapAcquire(ctx, "asr")` to have been called on `getContext()`
+ * — the `EngineVoiceBridge` lifecycle does this when voice input is armed.
+ */
+export declare class FfiBatchTranscriber extends BaseStreamingTranscriber {
+    private readonly ffi;
+    private readonly getContext;
+    private readonly windowSamples;
+    private readonly overlapSamples;
+    private readonly stepSamples;
+    /** All 16 kHz samples accumulated for the current speech segment. */
+    private buf;
+    /** Samples in `buf` already folded into `committed`. */
+    private committedSamples;
+    /** Text decoded from `buf[0 .. committedSamples)`. */
+    private committed;
+    /** `buf.length` at the last decode pass — throttles to `stepSamples`. */
+    private lastDecodeAt;
+    /** Decode chain — `asr_transcribe` calls serialize on the native ASR mutex anyway. */
+    private decodeChain;
+    constructor(opts: FfiBatchTranscriberOptions);
+    private decodeWindow;
+    protected onFrame(frame: PcmFrame): void;
+    protected onFlush(): Promise<TranscriptUpdate>;
+    protected onDispose(): void;
+    private resetSegment;
+    private scheduleDecode;
+    private runDecode;
+}
+export interface CreateStreamingTranscriberOptions {
+    /** Fused FFI handle (when a `libelizainference` build is loaded), else null. */
+    ffi?: ElizaInferenceFfi | null;
+    /** Provider for the fused context pointer (the bridge owns the lazy create). */
+    getContext?: () => ElizaInferenceContextHandle;
+    /**
+     * Whether a bundled ASR model directory is present. The fused path is
+     * only chosen when this is true AND the library advertises streaming
+     * ASR.
+     */
+    asrBundlePresent?: boolean;
+    /** VAD event stream to gate decoding (W1). */
+    vad?: VadEventSource;
+    /** Optional attribution metadata stamped onto emitted transcript updates. */
+    metadata?: TranscriptMetadataDefaults;
+    /** Convenience shorthand for `metadata.source`. */
+    source?: VoiceInputSource;
+    /** Fused-batch-interim window/step overrides (see `FfiBatchTranscriber`). */
+    ffiBatch?: Omit<FfiBatchTranscriberOptions, "ffi" | "getContext">;
+    /**
+     * Force a specific fused backend.
+     *   `"fused"`     → fused streaming ASR only (throws if unavailable),
+     *   `"ffi-batch"` → fused batch (interim) only (throws if unavailable),
+     *   `"auto"`      (default) → fused streaming → fused batch → throw.
+     */
+    prefer?: AsrBackendPreference;
+}
+/**
+ * Resolve the fused ASR adapter chain:
+ *   1. fused streaming ASR (`eliza_inference_asr_stream_*`, ABI v2 — the FINAL
+ *      path, W7),
+ *   2. fused batch (interim) — windowed `eliza_inference_asr_transcribe` (ABI
+ *      v1); contract-clean (one ggml, shared text vocab) and available now.
+ *
+ * The fused `libelizainference` build is the SOLE on-device ASR runtime. There
+ * is no whisper.cpp (or other second-runtime) fallback: if no fused decoder is
+ * available the caller gets a hard, actionable failure (AGENTS.md §3 + §9) —
+ * never a silent empty transcript.
+ */
+export declare function createStreamingTranscriber(opts?: CreateStreamingTranscriberOptions): StreamingTranscriber;
+//# sourceMappingURL=transcriber.d.ts.map

package/src/services/voice/transcriber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transcriber.d.ts","sourceRoot":"","sources":["transcriber.ts"],"names":[],"mappings":"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"}