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

package/src/services/voice/pipeline-impls.ts

@@ -0,0 +1,315 @@
+/**
+ * Concrete implementations of the `VoicePipeline` seams (`pipeline.ts`).
+ *
+ * `pipeline.ts` defines two interfaces — `DraftProposer`, `TargetVerifier`
+ * — plus the ASR contract (it consumes the live `StreamingTranscriber`
+ * from `voice/types.ts` directly) and an overlapped scheduler that drives
+ * the fused mic→speech graph from `packages/inference/AGENTS.md` §4. This
+ * module fills those interfaces against the live runtime:
+ *
+ *   - `MissingAsrTranscriber` — a `StreamingTranscriber` that hard-fails
+ *     when no ASR backend is available (AGENTS.md §3 — no silent cloud
+ *     fallback). The bridge's `resolveTranscriber()` returns this instead
+ *     of throwing eagerly so the failure surfaces at turn time.
+ *   - `MtpDraftProposer` — proposes a small MTP draft window from the
+ *     running in-process llama.cpp runtime; honours `cancel.cancelled`
+ *     between kernel ticks.
+ *   - `MtpTargetVerifier` — verifies against the text model's KV cache
+ *     and consumes exact verifier accept/reject events when the runtime
+ *     emits them.
+ *
+ * Hard-fail discipline (AGENTS.md §3 + §9): a missing fused ASR region in
+ * voice mode is a thrown `VoiceStartupError`, never a silent cloud
+ * fallback, never log-and-continue.
+ *
+ * Why a separate file from `pipeline.ts`: `pipeline.ts` stays
+ * dependency-light (it is the streaming contract, importable by text-only
+ * callers). The runtime wiring lives here so
+ * the contract module does not drag it in.
+ */
+
+import type { GenerateArgs } from "../backend";
+import { VoiceStartupError } from "./errors";
+import {
+	type DraftProposer,
+	splitTranscriptToTokens,
+	type TargetVerifier,
+} from "./pipeline";
+import type {
+	PcmFrame,
+	StreamingTranscriber,
+	TextToken,
+	TranscriptUpdate,
+	VerifierStreamEvent,
+} from "./types";
+
+/* ------------------------------------------------------------------ */
+/* ASR — missing-backend deferral                                      */
+/* ------------------------------------------------------------------ */
+
+/**
+ * A `StreamingTranscriber` that hard-fails: used when no ASR backend is
+ * available (no fused streaming decoder, no fused batch decoder, no
+ * bundled ASR region) but a voice turn was requested. AGENTS.md §3 —
+ * missing required voice backend in voice mode is a thrown
+ * `VoiceStartupError`, never a silent fallback. The bridge returns this
+ * from `resolveTranscriber()` so the failure surfaces when the pipeline
+ * actually feeds audio rather than at bridge construction.
+ */
+export class MissingAsrTranscriber implements StreamingTranscriber {
+	constructor(private readonly reason: string) {}
+	feed(_frame: PcmFrame): void {
+		throw new VoiceStartupError("missing-fused-build", this.reason);
+	}
+	async flush(): Promise<TranscriptUpdate> {
+		throw new VoiceStartupError("missing-fused-build", this.reason);
+	}
+	on(): () => void {
+		return () => {};
+	}
+	dispose(): void {}
+}
+
+/* ------------------------------------------------------------------ */
+/* MTP draft / verify                                                 */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Minimal surface of the running MTP text runtime the draft/verify
+ * adapters need. Kept structural so tests can pass a fake without
+ * standing up a real runtime.
+ */
+export interface MtpTextRunner {
+	/** True when MTP speculative decoding is enabled. */
+	hasDrafter(): boolean;
+	generateWithVerifierEvents(
+		args: GenerateArgs & {
+			onVerifierEvent: (event: VerifierStreamEvent) => void | Promise<void>;
+		},
+	): Promise<{ text: string }>;
+}
+
+/** Adapt a local-inference backend onto `MtpTextRunner`. */
+export function mtpTextRunner(runner: {
+	mtpEnabled(): boolean;
+	generateWithUsage(
+		args: GenerateArgs & {
+			onVerifierEvent: (event: VerifierStreamEvent) => void | Promise<void>;
+		},
+	): Promise<{ text: string }>;
+}): MtpTextRunner {
+	return {
+		hasDrafter() {
+			return runner.mtpEnabled();
+		},
+		async generateWithVerifierEvents(args) {
+			const { text } = await runner.generateWithUsage(args);
+			return { text };
+		},
+	};
+}
+
+/**
+ * Build the prompt string the drafter/verifier run against from the
+ * accepted prefix. The pipeline holds tokens, not a chat transcript; for
+ * the streaming verify loop we feed back the concatenated token text as a
+ * raw continuation prompt (`cache_prompt` on the server reuses the prefix
+ * KV between rounds so this is cheap to re-send).
+ */
+function prefixToPrompt(prefix: ReadonlyArray<TextToken>): string {
+	return prefix.map((t) => t.text).join("");
+}
+
+/**
+ * `DraftProposer` over native MTP. The runtime draft window already bounds
+ * proposals; this adapter additionally
+ * clamps to the pipeline's `maxDraft` and stops early on
+ * `cancel.cancelled`. GPU dispatch is N=1 (the fork's voice profile
+ * disables command-buffer batching — ledger §2 "Keep voice dispatch
+ * unbatched") so a barge-in lands at the next kernel boundary.
+ *
+ * Until the fork exposes a "draft only, return the proposed tokens"
+ * endpoint, the proposer issues a short low-temperature completion
+ * (`maxTokens = maxDraft`) and treats the produced tokens as the draft
+ * window. The verifier then re-checks them against the target's KV — the
+ * standard speculative-decoding contract, just with the draft sourced
+ * from the same server.
+ */
+export class MtpDraftProposer implements DraftProposer {
+	private readonly runner: MtpTextRunner;
+
+	constructor(runner: MtpTextRunner) {
+		this.runner = runner;
+	}
+
+	async propose(args: {
+		prefix: ReadonlyArray<TextToken>;
+		maxDraft: number;
+		cancel: { cancelled: boolean };
+	}): Promise<TextToken[]> {
+		if (args.cancel.cancelled) return [];
+		if (!this.runner.hasDrafter()) {
+			// No drafter wired ⇒ no speculation this round. The verifier still
+			// produces one token per round (plain AR step), so generation
+			// continues; MTP being mandatory is enforced at model load time.
+			return [];
+		}
+		const accepted: TextToken[] = [];
+		let nextIndex =
+			args.prefix.length > 0
+				? args.prefix[args.prefix.length - 1].index + 1
+				: 0;
+		await this.runner.generateWithVerifierEvents({
+			prompt: prefixToPrompt(args.prefix),
+			maxTokens: Math.max(1, Math.floor(args.maxDraft)),
+			temperature: 0,
+			signal: cancelToSignal(args.cancel),
+			onVerifierEvent: (event) => {
+				if (event.kind !== "accept") return;
+				for (const tok of event.tokens) {
+					if (accepted.length >= args.maxDraft) break;
+					accepted.push({ index: nextIndex++, text: tok.text });
+				}
+			},
+		});
+		if (args.cancel.cancelled) return [];
+		return accepted.slice(0, Math.max(1, Math.floor(args.maxDraft)));
+	}
+}
+
+/**
+ * `TargetVerifier` over the text model via MTP. Runs one
+ * autoregressive verify step against the runtime KV cache: it sends the
+ * accepted prefix and reads back the model's own continuation. The
+ * leading tokens that match the supplied `draft` are "accepted from
+ * draft"; the first mismatch is the correction; the model's `done` /
+ * stop is propagated.
+ *
+ * When the native fork emits exact verifier reject ranges, the
+ * `onVerifierEvent` callback already carries `kind: "reject"` events with
+ * the rejected token positions — this adapter records both and trusts the
+ * server's accept/reject split rather than re-deriving it.
+ */
+export class MtpTargetVerifier implements TargetVerifier {
+	private readonly runner: MtpTextRunner;
+	private readonly maxStep: number;
+
+	constructor(runner: MtpTextRunner, opts: { maxStep?: number } = {}) {
+		this.runner = runner;
+		this.maxStep = Math.max(1, Math.floor(opts.maxStep ?? 16));
+	}
+
+	async verify(args: {
+		prefix: ReadonlyArray<TextToken>;
+		draft: ReadonlyArray<TextToken>;
+		cancel: { cancelled: boolean };
+	}): Promise<{ accepted: TextToken[]; done: boolean }> {
+		if (args.cancel.cancelled) return { accepted: [], done: false };
+		// Step budget: enough to confirm the whole draft window plus one
+		// correction token (and a little headroom for the model's own bonus
+		// tokens past a fully-accepted draft).
+		const stepTokens = Math.min(
+			this.maxStep,
+			Math.max(1, args.draft.length + 1),
+		);
+		let nextIndex =
+			args.prefix.length > 0
+				? args.prefix[args.prefix.length - 1].index + 1
+				: 0;
+		const produced: TextToken[] = [];
+		let done = false;
+		const { text } = await this.runner.generateWithVerifierEvents({
+			prompt: prefixToPrompt(args.prefix),
+			maxTokens: stepTokens,
+			temperature: 0,
+			signal: cancelToSignal(args.cancel),
+			onVerifierEvent: (event) => {
+				if (event.kind === "accept") {
+					for (const tok of event.tokens) {
+						produced.push({ index: nextIndex++, text: tok.text });
+					}
+				}
+				// reject events: the server already retracted those positions
+				// from its own stream, so we just don't append them. Nothing else
+				// to do here — the chunker rollback is driven by the pipeline
+				// comparing `accepted` against `draft`.
+			},
+		});
+		if (args.cancel.cancelled) return { accepted: [], done: false };
+		if (produced.length === 0 && text.length > 0) {
+			// Non-streaming server (no per-delta events): fall back to splitting
+			// the returned text into tokens.
+			produced.push(...splitTranscriptToTokens(text, nextIndex));
+		}
+		// The model reached its natural stop when it produced fewer tokens
+		// than the step budget (it hit an EOS / stop sequence before the cap).
+		done = produced.length < stepTokens;
+		return { accepted: produced, done };
+	}
+}
+
+/* ------------------------------------------------------------------ */
+/* helpers                                                            */
+/* ------------------------------------------------------------------ */
+
+/**
+ * Bridge a `{cancelled: boolean}` flag (the pipeline's cancellation
+ * primitive — checked between kernel ticks) onto an `AbortSignal` so the
+ * local generation aborts when a barge-in fires.
+ *
+ * L6 — event-driven cancellation. The cancel token may expose an
+ * `onCancel(listener)` hook (set by the scheduler / pipeline when it
+ * wires the token up); when present, we fire `controller.abort()`
+ * synchronously from that hook and skip polling entirely. When the
+ * token is the plain `{cancelled: boolean}` POJO with no hook, we fall
+ * back to a coarse poll so a barge-in still lands in bounded time —
+ * but the hook-driven path is what voice barge-ins use in production.
+ */
+export interface CancelTokenWithSignal {
+	cancelled: boolean;
+	/**
+	 * Optional hook the token's owner fires synchronously when `cancelled`
+	 * flips from false to true. The listener returns nothing; calling it
+	 * after `cancelled` has already been set is a harmless no-op.
+	 */
+	onCancel?: (listener: () => void) => () => void;
+}
+
+function cancelToSignal(cancel: CancelTokenWithSignal): AbortSignal {
+	const controller = new AbortController();
+	if (cancel.cancelled) {
+		controller.abort();
+		return controller.signal;
+	}
+	if (typeof cancel.onCancel === "function") {
+		// Event-driven path — no polling. The owner fires the listener
+		// synchronously on barge-in; we abort the HTTP request at that
+		// instant. `once`: AbortController.abort() is idempotent but we
+		// still want to drop the listener to free the closure.
+		const unsubscribe = cancel.onCancel(() => {
+			controller.abort();
+		});
+		controller.signal.addEventListener("abort", () => unsubscribe(), {
+			once: true,
+		});
+		return controller.signal;
+	}
+	// Fallback: polling. Kept for tokens that don't expose the hook (e.g.
+	// tests that pass a plain `{cancelled}` POJO). The interval is short
+	// enough that an aborted-but-unhooked token still lands the abort
+	// before a typical kernel tick completes.
+	const timer = setInterval(() => {
+		if (cancel.cancelled) {
+			controller.abort();
+			clearInterval(timer);
+		}
+	}, 10);
+	// Don't keep the event loop alive purely for this poll.
+	if (typeof timer === "object" && timer && "unref" in timer) {
+		(timer as { unref(): void }).unref();
+	}
+	controller.signal.addEventListener("abort", () => clearInterval(timer), {
+		once: true,
+	});
+	return controller.signal;
+}

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

@@ -0,0 +1,216 @@
+/**
+ * Pipelined parallel-generation scheduler — the fused mic→speech graph
+ * from `packages/inference/AGENTS.md` §4:
+ *
+ *   mic / file → ASR → text tokens
+ *                      ↓
+ *                    scheduler ──→ MTP drafter (proposes N tokens)
+ *                                         ∥  (overlap, not sequential)
+ *                                  target verifier (text model)
+ *                                         ↓
+ *                                accepted tokens → phrase chunker
+ *                                         ↓                  ↘
+ *                              speaker preset (cached)    rollback queue
+ *                                         ↓                  ↙
+ *                                    OmniVoice TTS ←── on-reject: cancel chunk
+ *                                         ↓
+ *                                    PCM ring buffer → audio out
+ *
+ * The headline contract: **the moment ASR emits its last token, the
+ * MTP drafter starts drafting AND the target starts verifying — they
+ * overlap.** Drafter speculation N tokens ahead happens concurrently
+ * with the target verifying the previous window; accepted tokens are
+ * handed to the phrase chunker within the same scheduler tick.
+ *
+ * GPU command buffers stay N=1 (no command-buffer batching for voice)
+ * so a barge-in cancel lands at the next kernel boundary, not after a
+ * batch flush.
+ *
+ * Why this lives next to `VoiceScheduler` and not inside it: the
+ * scheduler owns the *audio* side (chunker → TTS → ring buffer →
+ * rollback → barge-in). This module owns the *text-generation* side
+ * (audio source → ASR → drafter∥verifier loop) and feeds accepted /
+ * rejected ranges into the scheduler. Keeping them separate keeps the
+ * scheduler usable from text-only callers (which reach the same nodes
+ * via the same scheduler — AGENTS.md §4) without an ASR/drafter
+ * dependency.
+ */
+import { PartialStabilizer } from "./partial-stabilizer";
+import type { VoiceScheduler } from "./scheduler";
+import type { StreamingTranscriber, TextToken, TranscriptionAudio, VerifierStreamEvent } from "./types";
+/**
+ * Split a transcript string into contiguous text tokens. The fused ASR
+ * tokenizer is shared with the text backbone (AGENTS.md §1 — zero
+ * re-tokenization), so the pipeline only needs *contiguous* token
+ * indices, not the model's exact subword boundaries; whitespace-aware
+ * word chunking is the closest stable approximation when only surface
+ * text is available. Empty input yields no tokens.
+ *
+ * `tokenIds`, when supplied, are the text-model vocabulary ids the fused
+ * ASR decoder emitted for `transcript`. When the lengths line up they are
+ * attached as `TextToken.id` so a downstream in-process handoff can skip
+ * re-tokenization; otherwise (mismatch — the surface split disagrees with
+ * the decoder's subword boundaries) the ids are dropped and only the
+ * word-chunk approximation is returned.
+ */
+export declare function splitTranscriptToTokens(transcript: string, startIndex?: number, tokenIds?: ReadonlyArray<number>): TextToken[];
+/**
+ * MTP drafter. `propose` returns up to `maxDraft` candidate
+ * continuation tokens given the accepted prefix. N=1 command buffers —
+ * the implementation MUST keep its GPU dispatch short enough to cancel
+ * at the next kernel boundary (no command-buffer batching for voice).
+ * Honours `cancel.cancelled` between kernel ticks.
+ */
+export interface DraftProposer {
+    propose(args: {
+        prefix: ReadonlyArray<TextToken>;
+        maxDraft: number;
+        cancel: {
+            cancelled: boolean;
+        };
+    }): Promise<TextToken[]>;
+}
+/**
+ * Target verifier (the text model). Given the accepted prefix plus a
+ * draft window, returns which leading draft tokens are accepted and the
+ * one corrected token at the first divergence (if any). When the draft
+ * is empty, the verifier still produces one token (plain autoregressive
+ * step). Honours `cancel.cancelled` between kernel ticks.
+ */
+export interface TargetVerifier {
+    verify(args: {
+        prefix: ReadonlyArray<TextToken>;
+        draft: ReadonlyArray<TextToken>;
+        cancel: {
+            cancelled: boolean;
+        };
+    }): Promise<{
+        accepted: TextToken[];
+        /** Set when the verifier reached the natural end of generation. */
+        done: boolean;
+    }>;
+}
+export interface VoicePipelineDeps {
+    scheduler: VoiceScheduler;
+    /**
+     * The live frame-fed ASR adapter (`voice/transcriber.ts` — fused
+     * `eliza_inference_asr_stream_*`, the fused batch adapter, or
+     * `MissingAsrTranscriber` deferring a hard failure). The pipeline drives
+     * it as a batch: it feeds the whole (VAD-gated) utterance buffer as one
+     * frame, `flush()`es to finalize, then splits the final transcript into
+     * contiguous text tokens (`splitTranscriptToTokens`). One `StreamingTranscriber`
+     * contract — there is no separate batch ASR interface.
+     */
+    transcriber: StreamingTranscriber;
+    drafter: DraftProposer;
+    verifier: TargetVerifier;
+}
+export interface VoicePipelineConfig {
+    /**
+     * Max tokens MTP drafts per round. Per-tier; small (≤8) so a
+     * rollback is cheap. The drafter and verifier overlap one round: while
+     * the verifier checks round k, the drafter speculates round k+1.
+     */
+    maxDraftTokens: number;
+    /**
+     * Hard cap on generated tokens per turn (safety stop). The verifier's
+     * `done` flag is the normal stop; this bounds a runaway model.
+     */
+    maxGeneratedTokens?: number;
+    /**
+     * A2 — when true, run streaming-ASR partials through a LocalAgreement-n
+     * stabilizer (`PartialStabilizer`) before splitting them into tokens
+     * and feeding the drafter. Off by default until the streaming-ASR
+     * fast path lands and validates the latency/quality trade. The
+     * `StreamingTranscriber.flush()`-driven batch path is unaffected (the
+     * stabilizer is a no-op on a single final partial).
+     */
+    usePartialStabilizer?: boolean;
+    /**
+     * A2 — agreement count `n` for `PartialStabilizer` when enabled.
+     * Ignored when `usePartialStabilizer` is false. Default 2.
+     */
+    partialStabilizerAgreementCount?: number;
+}
+export interface VoicePipelineEvents {
+    /** Fired once, the instant ASR emits its final token (= drafter+verifier kick-off). */
+    onAsrComplete?(tokens: ReadonlyArray<TextToken>): void;
+    /**
+     * Fired exactly once per turn, right after the ASR phase finishes and
+     * before the first drafter/verifier round. ASR → text → TTS are
+     * sequential within a turn (AGENTS.md §4), so the idle ASR-model pages
+     * can be dropped now — wire this to `MmapRegionHandle.evictPages()`
+     * (`madvise(MADV_DONTNEED)` on POSIX) for the ASR region to claw back
+     * ~1 GB of peak RSS while TTS decodes. The pages page back in
+     * transparently on the next turn's `feed()`; a host that prefers to
+     * keep ASR resident simply doesn't supply this hook. May be async; the
+     * pipeline does not block on it (a slow trim must not delay first audio).
+     */
+    onAsrPhaseComplete?(): void | Promise<void>;
+    /** Fired with each verifier accept/reject event before it hits the scheduler. */
+    onVerifierEvent?(event: VerifierStreamEvent): void;
+    /** Fired when the loop exits (verifier `done`, token cap, or barge-in cancel). */
+    onComplete?(reason: "done" | "token-cap" | "cancelled"): void;
+}
+/**
+ * One pipeline per active voice turn. Construct, call `run(audio)`,
+ * await the returned promise (or call `cancel()` for barge-in). The
+ * scheduler's barge-in controller also cancels an in-flight run — wire
+ * `bridge.triggerBargeIn()` and this run's `cancel()` to the same VAD
+ * signal so both the audio side (ring buffer drain) and the text side
+ * (stop drafting/verifying) abort together.
+ */
+export declare class VoicePipeline {
+    private readonly scheduler;
+    private readonly transcriber;
+    private readonly drafter;
+    private readonly verifier;
+    private readonly maxDraftTokens;
+    private readonly maxGeneratedTokens;
+    private readonly events;
+    /**
+     * A2 — when `config.usePartialStabilizer === true`, this is the active
+     * `PartialStabilizer` instance. Streaming-ASR consumers feed partials
+     * through it; the batch path in `transcribeAll()` collapses on a single
+     * final partial so the stabilizer is a no-op there. Exposed via
+     * `getPartialStabilizer()` so the streaming-ASR adapter (separate agent)
+     * can plug straight in once it ships.
+     */
+    private readonly partialStabilizer;
+    private active;
+    constructor(deps: VoicePipelineDeps, config: VoicePipelineConfig, events?: VoicePipelineEvents);
+    /** True while a turn is in flight. */
+    isRunning(): boolean;
+    /**
+     * A2 — the active `PartialStabilizer` when the pipeline was built with
+     * `usePartialStabilizer: true`, otherwise null. The streaming-ASR
+     * adapter (separate agent) feeds partials into this instance and
+     * forwards the `stable` portion downstream. Returning null when the
+     * feature flag is off lets the adapter skip the work entirely.
+     */
+    getPartialStabilizer(): PartialStabilizer | null;
+    /**
+     * Run one mic→speech turn. ASR streams first; the instant its last
+     * token lands, the drafter and verifier kick off concurrently and
+     * accepted tokens flow into the scheduler's chunker on the same tick.
+     * Resolves with the exit reason. Throws if a turn is already running.
+     */
+    run(audio: TranscriptionAudio): Promise<"done" | "token-cap" | "cancelled">;
+    /**
+     * Barge-in: cancel the in-flight turn. Stops ASR, stops the
+     * drafter/verifier loop at the next kernel boundary, and triggers the
+     * scheduler's barge-in (ring buffer drain + chunker flush + in-flight
+     * TTS cancel). No-op when no turn is running.
+     */
+    cancel(): void;
+    private execute;
+    /**
+     * Feed the whole utterance buffer to the live transcriber, finalize,
+     * and return the final transcript as contiguous text tokens. The
+     * transcriber is disposed afterwards (it is one per turn). A barge-in
+     * cancel checked before `flush()` short-circuits to an empty list.
+     */
+    private transcribeAll;
+    private finish;
+}
+//# sourceMappingURL=pipeline.d.ts.map

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

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