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

package/src/services/voice/asr-timed.real.test.ts

@@ -0,0 +1,141 @@
+/**
+ * Real-FFI test for fused ASR v12 per-word timings on REAL audio.
+ *
+ * Runs the ACTUAL fused `libelizainference` (`eliza_inference_asr_transcribe_timed`,
+ * ABI v12) end-to-end on a real speech recording (`native/omnivoice.cpp/
+ * examples/freeman.wav`) — decode → ASR → per-word `[startMs,endMs)` — and
+ * asserts the transcript is non-empty and the word timings satisfy the playback
+ * contract (`validateAsrWordTimings`) against the exact decoded audio duration.
+ *
+ * This is the single-pipe word-timing feature validated against real known
+ * audio, not a stub. Skipped (never faked) when:
+ *   - not running under Bun (`bun:ffi`),
+ *   - the fused lib is not resolvable (`ELIZA_INFERENCE_LIBRARY` /
+ *     `ELIZA_INFERENCE_LIB_DIR`, or a build under build-static-fused),
+ *   - no Eliza-1 ASR bundle is provided (`ELIZA_ASR_BUNDLE`, or the default
+ *     `~/.eliza/local-inference/models/eliza-1-0_8b.bundle`),
+ *   - the `freeman.wav` speech submodule isn't checked out,
+ *   - or the loaded build predates v12 (`timedAsrSupported() === false`).
+ * Runs via `bun test` (the post-merge lane runner — bun:ffi + `globalThis.Bun`);
+ * `*.real.test.ts` is excluded from the default `vitest.config.ts` lane.
+ *
+ * Reproduce locally (verified on this host):
+ *   B=~/.eliza/local-inference/models/eliza-1-asr-q8.bundle
+ *   hf download ggml-org/Qwen3-ASR-0.6B-GGUF Qwen3-ASR-0.6B-Q8_0.gguf --local-dir "$B/asr"
+ *   hf download ggml-org/Qwen3-ASR-0.6B-GGUF mmproj-Qwen3-ASR-0.6B-Q8_0.gguf --local-dir "$B/asr"
+ *   mv "$B/asr/Qwen3-ASR-0.6B-Q8_0.gguf" "$B/asr/eliza-1-asr.gguf"
+ *   mv "$B/asr/mmproj-Qwen3-ASR-0.6B-Q8_0.gguf" "$B/asr/eliza-1-asr-mmproj.gguf"
+ *   ELIZA_ASR_BUNDLE="$B" ELIZA_INFERENCE_LIBRARY=<built libelizainference.so> \
+ *     bun test src/services/voice/asr-timed.real.test.ts
+ * The fused `eliza_pick_asr_files` resolves an ASR-only bundle from
+ * `<bundle>/asr/`; no text/TTS model or manifest is needed for the ASR region.
+ * Observed: transcript "If you go into different cultures, they have different
+ * concepts of creation." — 12 words, monotonic + non-overlapping, ~2.3s CPU.
+ */
+
+import { existsSync, readFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { validateAsrWordTimings } from "@elizaos/shared/transcripts";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { resolveFusedLibraryPath } from "../desktop-fused-ffi-backend-runtime";
+import { decodeMonoPcm16Wav } from "./engine-bridge";
+import {
+	type ElizaInferenceContextHandle,
+	type ElizaInferenceFfi,
+	loadElizaInferenceFfi,
+} from "./ffi-bindings";
+
+const isBun = typeof (globalThis as { Bun?: unknown }).Bun !== "undefined";
+const LIB_PATH =
+	resolveFusedLibraryPath(null, process.env) ??
+	(() => {
+		const built = fileURLToPath(
+			new URL(
+				"../../../native/llama.cpp/build-static-fused/bin/libelizainference.so",
+				import.meta.url,
+			),
+		);
+		return existsSync(built) ? built : null;
+	})();
+
+const BUNDLE =
+	process.env.ELIZA_ASR_BUNDLE?.trim() ||
+	path.join(os.homedir(), ".eliza/local-inference/models/eliza-1-0_8b.bundle");
+const HAVE_BUNDLE = existsSync(BUNDLE);
+
+const FREEMAN_WAV = fileURLToPath(
+	new URL(
+		"../../../native/omnivoice.cpp/examples/freeman.wav",
+		import.meta.url,
+	),
+);
+const HAVE_FREEMAN = existsSync(FREEMAN_WAV);
+
+// NOTE: vitest workers do not run the bun runtime, so bun:ffi is unavailable and
+// this suite skips under `vitest`. The RUNNABLE real-ASR lane is the direct-bun
+// smoke at scripts/asr-real-smoke.ts (`bun run test:asr:real`), which actually
+// loads the fused lib and transcribes real audio. This vitest suite stays for
+// IDE/local runs under a bun-capable runner.
+describe.skipIf(!isBun || !LIB_PATH || !HAVE_BUNDLE)(
+	"fused ASR v12 per-word timings — real FFI on real audio",
+	() => {
+		let ffi: ElizaInferenceFfi;
+		let ctx: ElizaInferenceContextHandle;
+
+		beforeAll(() => {
+			ffi = loadElizaInferenceFfi(LIB_PATH as string);
+			ctx = ffi.create(BUNDLE);
+			ffi.mmapAcquire(ctx, "asr");
+		});
+		afterAll(() => {
+			if (ffi && ctx) {
+				ffi.mmapEvict(ctx, "asr");
+				ffi.destroy(ctx);
+			}
+			ffi?.close();
+		});
+
+		it("loads a v12 build that advertises timed ASR", () => {
+			expect(ffi.libraryAbiVersion).toBe("12");
+			expect(ffi.timedAsrSupported()).toBe(true);
+		});
+
+		it.skipIf(!HAVE_FREEMAN)(
+			"transcribes freeman.wav with well-formed per-word timings",
+			() => {
+				const { pcm, sampleRate } = decodeMonoPcm16Wav(
+					new Uint8Array(readFileSync(FREEMAN_WAV)),
+				);
+				const audioDurationMs = (pcm.length / sampleRate) * 1000;
+
+				const { text, words } = ffi.asrTranscribeTimed({
+					ctx,
+					pcm,
+					sampleRateHz: sampleRate,
+				});
+
+				// Real speech → a non-empty transcript with at least a few words.
+				expect(text.trim().length).toBeGreaterThan(0);
+				expect(words.length).toBeGreaterThan(2);
+
+				// Every emitted span is ordered, non-overlapping, and inside the
+				// real audio duration — the contract the player highlights against.
+				const validation = validateAsrWordTimings(words, audioDurationMs);
+				expect(validation.violations).toEqual([]);
+				expect(validation.ok).toBe(true);
+
+				// The final word ends at (≈) the true end of the audio.
+				const last = words[words.length - 1];
+				expect(last).toBeDefined();
+				expect((last as { endMs: number }).endMs).toBeLessThanOrEqual(
+					audioDurationMs + 1,
+				);
+				expect((last as { endMs: number }).endMs).toBeGreaterThan(
+					audioDurationMs * 0.5,
+				);
+			},
+		);
+	},
+);

package/src/services/voice/audio-frame-consumer.d.ts

@@ -0,0 +1,212 @@
+/**
+ * AudioFrameConsumer — turn the Android `audioFrame` PCM stream into live,
+ * VAD-segmented, speaker-attributed voice turns.
+ *
+ * The Android native capture path (`plugin-native-talkmode`) streams an
+ * `audioFrame` Capacitor event: base64 little-endian s16 mono PCM at 16 kHz,
+ * 20 ms per frame, plus `{ sampleRate, channels, samples, rms, timestamp,
+ * frameIndex }`. This module is the platform-agnostic consumer that subscribes
+ * to that stream (wherever the bun:ffi voice libs are present) and runs:
+ *
+ *   audioFrame (base64 LE-s16) → decode → VadDetector (turn segmentation)
+ *     → on speech-end: VoiceAttributionPipeline.attribute(turn PCM)
+ *       → handleLiveVoiceAttribution → VOICE_TURN_OBSERVED + voiceTurnSignal
+ *
+ * Design notes:
+ *  - It does NOT reinvent VAD: it drives the existing `VadDetector` state
+ *    machine (`speech-start` / `speech-pause` / `speech-end`), reusing its
+ *    Silero onset/offset/hangover logic. It buffers the turn's PCM between
+ *    `speech-start` and `speech-end`, then attributes the whole utterance.
+ *  - Every native dependency (`VadDetector`, `VoiceAttributionPipeline`, the
+ *    runtime) is INJECTED, so the consumer is fully unit-testable with fakes
+ *    and has no static import of bun:ffi. A `build*` factory in the smoke
+ *    harness wires the real ggml-backed deps.
+ *  - The decode boundary (`decodeAudioFramePcm`) is the ONLY place that knows
+ *    the wire format (base64 LE-s16). Internally everything is Float32 [-1,1].
+ *
+ * What this module does NOT do: it does not transcribe (ASR text is the
+ * separate streaming-ASR path) and it does not own the WebView→agent
+ * transport — see `android/AUDIO_FRAMES.md` and `LIVE_PIPELINE.md` for the
+ * remaining device wiring.
+ */
+import { type EmitVoiceTurnObservedArgs, type HandleLiveVoiceAttributionOptions } from "../../runtime/voice-entity-binding.js";
+import type { VoiceTurnSignal } from "./eot-classifier.js";
+import type { VoiceAttributionOutput, VoiceAttributionPipeline } from "./speaker/attribution-pipeline.js";
+import type { PcmFrame, VadEvent, VoiceInputSource } from "./types.js";
+/**
+ * The `audioFrame` event payload, mirroring `TalkModeAudioFrameEvent` in
+ * `@elizaos/capacitor-talkmode`. Re-declared structurally here so this
+ * package does not take a build dep on the Capacitor plugin.
+ */
+export interface AudioFrameEvent {
+    /** Base64-encoded little-endian signed 16-bit mono PCM for this frame. */
+    pcm16: string;
+    /** Sample rate of the captured PCM in Hz (e.g. 16000). */
+    sampleRate: number;
+    /** Channel count (always 1 — mono). */
+    channels: number;
+    /** Number of PCM samples in this frame (`pcm16` byte length / 2). */
+    samples: number;
+    /** RMS amplitude of this frame, normalized 0..1. */
+    rms: number;
+    /** Monotonic capture timestamp for this frame, ms. */
+    timestamp: number;
+    /** Running index of this frame since capture started (0-based). */
+    frameIndex: number;
+}
+/** The sample rate every voice model in this pipeline is dimensioned for. */
+export declare const AUDIO_FRAME_PIPELINE_SAMPLE_RATE = 16000;
+export declare class AudioFrameDecodeError extends Error {
+    constructor(message: string);
+}
+/**
+ * Decode an `audioFrame` payload into a Float32 [-1, 1] window. This is the
+ * single boundary that understands the base64 LE-s16 wire format.
+ *
+ * The native capture path only ever produces 16 kHz mono; this asserts that
+ * invariant rather than resampling silently (the downstream Silero/WeSpeaker
+ * graphs are 16 kHz-only — a wrong rate is a bug to surface, not paper over).
+ */
+export declare function decodeAudioFramePcm(frame: AudioFrameEvent): Float32Array;
+/**
+ * The structural slice of `VadDetector` the consumer needs. Taking the
+ * structural view (not the concrete class) keeps the consumer testable with a
+ * fake VAD and avoids pulling the optional native VAD surface into callers
+ * that only want to feed frames.
+ */
+export interface VadSegmenter {
+    /** True while a speech segment (incl. its pause hangover) is open. */
+    readonly inSpeech: boolean;
+    /** Subscribe to the authoritative VAD timeline. Returns an unsubscribe fn. */
+    onVadEvent(listener: (event: VadEvent) => void): () => void;
+    /** Feed one mic frame; resolves once its windows are processed. */
+    pushFrame(frame: PcmFrame): Promise<void>;
+    /** Flush trailing samples and finalize any open segment. */
+    flush(): Promise<void>;
+    /** Clear all state at a hard boundary. */
+    reset(): void;
+}
+/**
+ * The structural slice of `VoiceAttributionPipeline` the consumer needs.
+ */
+export interface AttributionPipelineLike {
+    attribute(req: Parameters<VoiceAttributionPipeline["attribute"]>[0]): Promise<VoiceAttributionOutput>;
+}
+/**
+ * The structural slice of `IAgentRuntime` the consumer needs:
+ * `handleLiveVoiceAttribution` calls `emitEvent`.
+ */
+export interface RuntimeEventSink {
+    emitEvent(type: unknown, payload: Record<string, unknown>): Promise<void>;
+}
+export interface AudioFrameConsumerDeps {
+    /** Turn-segmentation VAD (drives speech-start/pause/end). */
+    vad: VadSegmenter;
+    /** Diarization + speaker-attribution pipeline. */
+    pipeline: AttributionPipelineLike;
+    /** Runtime event sink for VOICE_TURN_OBSERVED. */
+    runtime: RuntimeEventSink;
+}
+export interface AudioFrameConsumerConfig {
+    /** Source metadata stamped onto every attributed turn. */
+    source?: VoiceInputSource;
+    /** Gating options forwarded to `handleLiveVoiceAttribution` per turn. */
+    attributionOptions?: HandleLiveVoiceAttributionOptions;
+    /**
+     * Hard cap on a single buffered turn, in seconds. A speaker who never
+     * triggers `speech-end` (e.g. continuous noise) must not grow the buffer
+     * without bound. When exceeded the turn is force-finalized. Default 30 s.
+     */
+    maxTurnSeconds?: number;
+    /**
+     * Pre-roll seconds of audio kept before `speech-start` so the onset of the
+     * first word (which the VAD only confirms a window or two in) is not clipped
+     * out of the attribution buffer. Default 0.3 s.
+     */
+    preRollSeconds?: number;
+}
+/** A finalized, attributed turn the consumer surfaces to its caller. */
+export interface AttributedTurn {
+    turnId: string;
+    output: VoiceAttributionOutput;
+    signal: VoiceTurnSignal;
+    /** Turn span in the mic-clock (frame `timestamp`) domain. */
+    startedAtMs: number;
+    endedAtMs: number;
+    /** Total buffered turn samples that were attributed. */
+    samples: number;
+}
+export type AttributedTurnListener = (turn: AttributedTurn) => void;
+/**
+ * Drives the `audioFrame` → VAD turn-segmentation → attribution → signal
+ * pipeline. One instance per capture session.
+ *
+ * Frame ingestion is serialized through the injected VAD's `pushFrame`
+ * (which itself serializes the Silero forward pass), so `onAudioFrame` is
+ * safe to fire-and-forget from a Capacitor event listener; turns surface in
+ * order via `onTurn`.
+ */
+export declare class AudioFrameConsumer {
+    private readonly vad;
+    private readonly pipeline;
+    private readonly runtime;
+    private readonly source;
+    private readonly attributionOptions;
+    private readonly maxTurnSamples;
+    private readonly preRollSamples;
+    private readonly unsubscribeVad;
+    private readonly turnListeners;
+    /** Float32 chunks of the in-flight turn, oldest first. */
+    private turnChunks;
+    private turnSamples;
+    /** Rolling pre-roll ring (frames captured before speech-start). */
+    private preRoll;
+    private preRollSampleCount;
+    private capturing;
+    private turnSeq;
+    private turnStartedAtMs;
+    private lastFrameEndMs;
+    /** Serialized attribution chain so turns finalize one at a time, in order. */
+    private attributing;
+    private closed;
+    /** Count of frames that failed to decode (surfaced via getters, not thrown). */
+    droppedFrames: number;
+    constructor(deps: AudioFrameConsumerDeps, config?: AudioFrameConsumerConfig);
+    /** True while a turn is being buffered (between speech-start and speech-end). */
+    get inTurn(): boolean;
+    /** Subscribe to finalized attributed turns. Returns an unsubscribe fn. */
+    onTurn(listener: AttributedTurnListener): () => void;
+    /**
+     * Feed one decoded-or-raw `audioFrame`. Accepts either the wire-format
+     * `AudioFrameEvent` (decoded here) or a pre-decoded Float32 window with the
+     * frame's mic-clock timestamp. Resolves once the frame's VAD windows are
+     * processed.
+     */
+    onAudioFrame(frame: AudioFrameEvent): Promise<void>;
+    /**
+     * Feed a pre-decoded Float32 16 kHz window with its mic-clock timestamp
+     * (ms). The decode boundary already ran; used by transports that decode
+     * upstream and by the host harness.
+     */
+    pushDecodedFrame(pcm: Float32Array, timestampMs: number): Promise<void>;
+    /**
+     * Flush the VAD (finalize any open segment) and await all pending
+     * attribution. Call at end-of-capture so a trailing utterance is not lost.
+     */
+    flush(): Promise<void>;
+    /** Release listeners and clear all buffers. Idempotent. */
+    close(): Promise<void>;
+    private onVadEvent;
+    private beginTurn;
+    private finalizeTurn;
+    private attributeTurn;
+    private appendTurnChunk;
+    private appendPreRoll;
+}
+/**
+ * Re-export of the producer's emit args, so a consumer caller can construct a
+ * VOICE_TURN_OBSERVED payload directly when wiring a custom transport without
+ * importing the runtime subpath twice.
+ */
+export type { EmitVoiceTurnObservedArgs };
+//# sourceMappingURL=audio-frame-consumer.d.ts.map

package/src/services/voice/audio-frame-consumer.d.ts.map

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