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

package/src/services/voice/phrase-chunker.test.ts

@@ -0,0 +1,239 @@
+import { describe, expect, it } from "vitest";
+import { type ClockMs, chunkTokens, PhraseChunker } from "./phrase-chunker";
+import type { TextToken } from "./types";
+
+function tokens(parts: string[]): TextToken[] {
+	return parts.map((text, index) => ({ index, text }));
+}
+
+describe("PhraseChunker punctuation boundaries", () => {
+	it("flushes on semicolon and colon boundaries for faster first audio", () => {
+		const phrases = chunkTokens(tokens(["First:", " second;", " third"]), {});
+
+		expect(phrases.map((phrase) => phrase.text)).toEqual([
+			"First:",
+			" second;",
+			" third",
+		]);
+		expect(phrases.map((phrase) => phrase.terminator)).toEqual([
+			"punctuation",
+			"punctuation",
+			"max-cap",
+		]);
+	});
+});
+
+describe("PhraseChunker T3 time-budget flush", () => {
+	it("force-flushes once the time budget elapses on a slow producer", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			// Pin first-phrase budget == full budget so these mechanism tests
+			// exercise the uniform 200ms path (first-phrase shortening is
+			// covered separately below).
+			{
+				maxAccumulationMs: 200,
+				firstPhraseMaxAccumulationMs: 200,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+
+		expect(chunker.push({ index: 0, text: "hello", acceptedAt: 0 })).toBeNull();
+		now = 100;
+		expect(
+			chunker.push({ index: 1, text: " there", acceptedAt: 0 }),
+		).toBeNull();
+		now = 220;
+		const flushed = chunker.push({ index: 2, text: " friend", acceptedAt: 0 });
+		expect(flushed).not.toBeNull();
+		expect(flushed?.text).toBe("hello there friend");
+		expect(flushed?.terminator).toBe("max-cap");
+	});
+
+	it("does not flush before the budget elapses", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			// Pin first-phrase budget == full budget so these mechanism tests
+			// exercise the uniform 200ms path (first-phrase shortening is
+			// covered separately below).
+			{
+				maxAccumulationMs: 200,
+				firstPhraseMaxAccumulationMs: 200,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		expect(chunker.push({ index: 0, text: "a", acceptedAt: 0 })).toBeNull();
+		now = 50;
+		expect(chunker.push({ index: 1, text: "b", acceptedAt: 0 })).toBeNull();
+		now = 150;
+		expect(chunker.push({ index: 2, text: "c", acceptedAt: 0 })).toBeNull();
+	});
+
+	it("flushIfTimeBudgetExceeded triggers on caller poll without a new token", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			// Pin first-phrase budget == full budget so these mechanism tests
+			// exercise the uniform 200ms path (first-phrase shortening is
+			// covered separately below).
+			{
+				maxAccumulationMs: 200,
+				firstPhraseMaxAccumulationMs: 200,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		chunker.push({ index: 0, text: "x", acceptedAt: 0 });
+		now = 100;
+		expect(chunker.flushIfTimeBudgetExceeded()).toBeNull();
+		now = 250;
+		const phrase = chunker.flushIfTimeBudgetExceeded();
+		expect(phrase?.text).toBe("x");
+		expect(phrase?.terminator).toBe("max-cap");
+		expect(chunker.flushIfTimeBudgetExceeded()).toBeNull();
+	});
+
+	it("msUntilTimeBudget reports infinity for an empty buffer or disabled budget", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			// Pin first-phrase budget == full budget so these mechanism tests
+			// exercise the uniform 200ms path (first-phrase shortening is
+			// covered separately below).
+			{
+				maxAccumulationMs: 200,
+				firstPhraseMaxAccumulationMs: 200,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		expect(chunker.msUntilTimeBudget()).toBe(Number.POSITIVE_INFINITY);
+		chunker.push({ index: 0, text: "x", acceptedAt: 0 });
+		expect(chunker.msUntilTimeBudget()).toBe(200);
+		now = 75;
+		expect(chunker.msUntilTimeBudget()).toBe(125);
+
+		const disabled = new PhraseChunker(
+			{ maxAccumulationMs: 0, maxTokensPerPhrase: 100 },
+			null,
+			clock,
+		);
+		disabled.push({ index: 0, text: "x", acceptedAt: 0 });
+		expect(disabled.msUntilTimeBudget()).toBe(Number.POSITIVE_INFINITY);
+	});
+
+	it("disabled budget never time-flushes", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			{ maxAccumulationMs: 0, maxTokensPerPhrase: 100 },
+			null,
+			clock,
+		);
+		chunker.push({ index: 0, text: "a", acceptedAt: 0 });
+		now = 10_000;
+		expect(chunker.push({ index: 1, text: " b", acceptedAt: 0 })).toBeNull();
+		expect(chunker.flushIfTimeBudgetExceeded()).toBeNull();
+	});
+});
+
+describe("PhraseChunker first-phrase budget (TTFA)", () => {
+	it("flushes the first phrase on the shorter budget, later phrases on the full one", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			{
+				maxAccumulationMs: 700,
+				firstPhraseMaxAccumulationMs: 300,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		// First phrase: silent producer, no punctuation — flushes at 300ms.
+		expect(chunker.push({ index: 0, text: "hello", acceptedAt: 0 })).toBeNull();
+		expect(chunker.msUntilTimeBudget()).toBe(300);
+		now = 300;
+		const first = chunker.flushIfTimeBudgetExceeded();
+		expect(first?.text).toBe("hello");
+		expect(first?.terminator).toBe("max-cap");
+
+		// Second phrase now uses the FULL 700ms budget (no fragmentation).
+		now = 1000;
+		expect(
+			chunker.push({ index: 1, text: " there", acceptedAt: 0 }),
+		).toBeNull();
+		expect(chunker.msUntilTimeBudget()).toBe(700);
+		now = 1300; // 300ms in — would have flushed the first phrase, not this one
+		expect(chunker.flushIfTimeBudgetExceeded()).toBeNull();
+		now = 1700; // full 700ms elapsed
+		expect(chunker.flushIfTimeBudgetExceeded()?.text).toBe(" there");
+	});
+
+	it("derives the first-phrase budget from maxAccumulationMs when unset (half, capped 350)", () => {
+		const now = 0;
+		const clock: ClockMs = () => now;
+		// 700ms full → first-phrase budget = min(350, 350) = 350.
+		const chunker = new PhraseChunker(
+			{ maxAccumulationMs: 700, maxTokensPerPhrase: 100 },
+			null,
+			clock,
+		);
+		chunker.push({ index: 0, text: "x", acceptedAt: 0 });
+		expect(chunker.msUntilTimeBudget()).toBe(350);
+
+		// 400ms full → half = 200 (below the 350 cap).
+		const small = new PhraseChunker(
+			{ maxAccumulationMs: 400, maxTokensPerPhrase: 100 },
+			null,
+			clock,
+		);
+		small.push({ index: 0, text: "x", acceptedAt: 0 });
+		expect(small.msUntilTimeBudget()).toBe(200);
+	});
+
+	it("resets the first-phrase gate on reset() so each reply gets fast first audio", () => {
+		let now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			{
+				maxAccumulationMs: 700,
+				firstPhraseMaxAccumulationMs: 300,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		chunker.push({ index: 0, text: "first", acceptedAt: 0 });
+		now = 300;
+		expect(chunker.flushIfTimeBudgetExceeded()).not.toBeNull(); // phrase #1 flushed
+		chunker.reset();
+		now = 1000;
+		chunker.push({ index: 0, text: "again", acceptedAt: 0 });
+		// Back to the short first-phrase budget after reset.
+		expect(chunker.msUntilTimeBudget()).toBe(300);
+	});
+
+	it("clamps an explicit first-phrase budget to the full budget", () => {
+		const now = 0;
+		const clock: ClockMs = () => now;
+		const chunker = new PhraseChunker(
+			{
+				maxAccumulationMs: 200,
+				firstPhraseMaxAccumulationMs: 999,
+				maxTokensPerPhrase: 100,
+			},
+			null,
+			clock,
+		);
+		chunker.push({ index: 0, text: "x", acceptedAt: 0 });
+		expect(chunker.msUntilTimeBudget()).toBe(200);
+	});
+});

package/src/services/voice/phrase-chunker.ts

@@ -0,0 +1,281 @@
+import type { PhonemeTokenizer } from "./phoneme-tokenizer";
+import type {
+	AcceptedToken,
+	Phrase,
+	PhraseChunkerConfig,
+	TextToken,
+} from "./types";
+
+/**
+ * Default phrase boundaries: end-of-clause punctuation plus the three
+ * sentence-final marks. Per `packages/inference/AGENTS.md` §4 / the
+ * voice-swarm brief item A6 — "the first segment delimited by punctuation
+ * OR the first 30 words, whichever comes first". Cutting a phrase at the
+ * first comma/semicolon/colon hands TTS something to say without waiting
+ * for a sentence-final mark.
+ */
+const DEFAULT_TERMINATORS: ReadonlySet<string> = new Set([
+	",",
+	".",
+	"!",
+	"?",
+	";",
+	":",
+]);
+const DEFAULT_PHONEMES_PER_CHUNK = 8;
+/** Default hard word cap when a caller doesn't supply `maxTokensPerPhrase` (the brief's "first 30 words"). */
+const DEFAULT_MAX_TOKENS_PER_PHRASE = 30;
+/**
+ * T3 — default time budget in milliseconds for the time-budget phrase
+ * flush. When a phrase has been accumulating in the buffer for this long
+ * without hitting a punctuation / phoneme / cap boundary, force a flush
+ * so the next phrase reaches TTS instead of stalling behind a slow
+ * producer. Override via `ELIZA_PHRASE_FLUSH_MS` env var.
+ *
+ * The default is deliberately phrase-sized. A 200ms budget was fast on paper
+ * but split slow token streams into word fragments, which made OmniVoice
+ * produce filler-like audio and degraded the downstream ASR loop.
+ */
+function resolveDefaultMaxAccumulationMs(): number {
+	const raw = process.env.ELIZA_PHRASE_FLUSH_MS?.trim();
+	if (raw) {
+		const v = Number.parseInt(raw, 10);
+		if (Number.isFinite(v) && v > 0) return v;
+	}
+	return 700;
+}
+const DEFAULT_MAX_ACCUMULATION_MS = resolveDefaultMaxAccumulationMs();
+
+/**
+ * First-audio (TTFA) optimization: the FIRST phrase of a reply uses a shorter
+ * time budget than the rest. First-audio latency is the dominant voice-UX
+ * metric, and a punctuation-sparse opening otherwise waits the full
+ * {@link DEFAULT_MAX_ACCUMULATION_MS} before any sound plays. Once audio is
+ * flowing, later phrases keep the full budget so the bulk of the reply is not
+ * fragmented into word-sized chunks (the failure mode the 700ms default fixed).
+ * Override via `ELIZA_PHRASE_FLUSH_FIRST_MS`; defaults to half the full budget,
+ * capped at 350ms. A non-positive full budget disables both.
+ */
+function resolveFirstPhraseMs(fullBudgetMs: number): number {
+	if (fullBudgetMs <= 0) return 0;
+	const raw = process.env.ELIZA_PHRASE_FLUSH_FIRST_MS?.trim();
+	if (raw) {
+		const v = Number.parseInt(raw, 10);
+		if (Number.isFinite(v) && v > 0) return Math.min(v, fullBudgetMs);
+	}
+	return Math.min(350, Math.ceil(fullBudgetMs / 2));
+}
+
+/** Wall-clock source the chunker uses. Tests inject a deterministic clock. */
+export type ClockMs = () => number;
+
+const DEFAULT_CLOCK: ClockMs = () => globalThis.performance.now();
+
+export class PhraseChunker {
+	private buffer: AcceptedToken[] = [];
+	private nextPhraseId = 0;
+	private readonly terminators: ReadonlySet<string>;
+	private readonly chunkOn: "punctuation" | "phoneme-stream";
+	private readonly phonemesPerChunk: number;
+	private readonly maxTokensPerPhrase: number;
+	private readonly tokenizer: PhonemeTokenizer | null;
+	private phonemeCount = 0;
+	/**
+	 * T3 — time-budget flush. `firstTokenAtMs` is captured on the first
+	 * `push()` after an empty buffer; once `clock() - firstTokenAtMs >=
+	 * maxAccumulationMs` the chunker force-flushes even without a
+	 * punctuation / phoneme / cap boundary. `maxAccumulationMs <= 0`
+	 * disables the time budget.
+	 */
+	private readonly maxAccumulationMs: number;
+	/** Shorter budget applied only while no phrase has flushed yet this reply. */
+	private readonly firstPhraseMaxAccumulationMs: number;
+	private readonly clock: ClockMs;
+	private firstTokenAtMs = 0;
+	/** Phrases emitted since the last {@link reset}; gates the first-phrase budget. */
+	private phrasesEmitted = 0;
+
+	constructor(
+		config: PhraseChunkerConfig,
+		tokenizer: PhonemeTokenizer | null = null,
+		clock: ClockMs = DEFAULT_CLOCK,
+	) {
+		this.terminators = config.sentenceTerminators ?? DEFAULT_TERMINATORS;
+		this.chunkOn = config.chunkOn ?? "punctuation";
+		this.phonemesPerChunk = Math.max(
+			1,
+			config.phonemesPerChunk ?? DEFAULT_PHONEMES_PER_CHUNK,
+		);
+		this.maxTokensPerPhrase = Math.max(
+			1,
+			config.maxTokensPerPhrase ?? DEFAULT_MAX_TOKENS_PER_PHRASE,
+		);
+		this.maxAccumulationMs =
+			config.maxAccumulationMs !== undefined
+				? Math.max(0, config.maxAccumulationMs)
+				: DEFAULT_MAX_ACCUMULATION_MS;
+		this.firstPhraseMaxAccumulationMs =
+			config.firstPhraseMaxAccumulationMs !== undefined
+				? Math.min(
+						this.maxAccumulationMs,
+						Math.max(0, config.firstPhraseMaxAccumulationMs),
+					)
+				: resolveFirstPhraseMs(this.maxAccumulationMs);
+		this.clock = clock;
+		this.tokenizer = tokenizer;
+		if (this.chunkOn === "phoneme-stream" && this.tokenizer === null) {
+			throw new Error(
+				"PhraseChunker: chunkOn='phoneme-stream' requires a PhonemeTokenizer",
+			);
+		}
+	}
+
+	push(token: AcceptedToken): Phrase | null {
+		if (this.buffer.length === 0) {
+			this.firstTokenAtMs = this.clock();
+		}
+		this.buffer.push(token);
+
+		// Punctuation always wins — a `, . ! ?` boundary forces a flush even
+		// in phoneme-stream mode.
+		if (this.endsWithTerminator(token.text)) {
+			return this.flushAs("punctuation");
+		}
+
+		if (this.chunkOn === "phoneme-stream" && this.tokenizer !== null) {
+			const phonemes = this.tokenizer.tokenize(token.text, token.index);
+			this.phonemeCount += phonemes.length;
+			if (this.phonemeCount >= this.phonemesPerChunk) {
+				return this.flushAs("phoneme-stream");
+			}
+		}
+
+		if (this.buffer.length >= this.maxTokensPerPhrase) {
+			return this.flushAs("max-cap");
+		}
+
+		// T3 — time-budget flush. Re-uses the `"max-cap"` terminator because
+		// adding a new terminator value would require editing the shared
+		// `Phrase` type in `types.ts`. Structurally "the chunker forced a
+		// flush" is what max-cap already means.
+		const budget = this.currentBudgetMs();
+		if (budget > 0 && this.clock() - this.firstTokenAtMs >= budget) {
+			return this.flushAs("max-cap");
+		}
+		return null;
+	}
+
+	/** Active time budget: the shorter first-phrase budget until the reply's
+	 * first phrase has flushed, then the full budget. */
+	private currentBudgetMs(): number {
+		return this.phrasesEmitted === 0
+			? this.firstPhraseMaxAccumulationMs
+			: this.maxAccumulationMs;
+	}
+
+	/**
+	 * T3 — caller-driven check. Returns a phrase when the time budget has
+	 * elapsed for the current buffer, otherwise null. The scheduler polls
+	 * this from a `setTimeout` so even a producer that goes silent before
+	 * pushing the next token still gets its in-flight phrase flushed.
+	 */
+	flushIfTimeBudgetExceeded(): Phrase | null {
+		if (this.buffer.length === 0) return null;
+		const budget = this.currentBudgetMs();
+		if (budget <= 0) return null;
+		if (this.clock() - this.firstTokenAtMs < budget) {
+			return null;
+		}
+		return this.flushAs("max-cap");
+	}
+
+	/**
+	 * T3 — milliseconds remaining until the time budget elapses for the
+	 * current buffer. Negative when the budget has already been exceeded;
+	 * `Number.POSITIVE_INFINITY` when the buffer is empty or the budget is
+	 * disabled. Callers compute their flush timer off this.
+	 */
+	msUntilTimeBudget(): number {
+		if (this.buffer.length === 0) return Number.POSITIVE_INFINITY;
+		const budget = this.currentBudgetMs();
+		if (budget <= 0) return Number.POSITIVE_INFINITY;
+		return this.firstTokenAtMs + budget - this.clock();
+	}
+
+	flushPending(): Phrase | null {
+		if (this.buffer.length === 0) return null;
+		return this.flushAs("max-cap");
+	}
+
+	/**
+	 * Drop buffered tokens that have not flushed whose token index is ≥
+	 * `fromIndex`. Used by the pipeline's rollback path: when the target
+	 * verifier rejects a draft tail, any draft tokens still sitting in the
+	 * chunker's buffer before phrase packing MUST be discarded so
+	 * the verifier's correction does not get glued onto stale text.
+	 * Phonemes are recounted from scratch over what remains.
+	 */
+	dropPendingFrom(fromIndex: number): void {
+		const kept = this.buffer.filter((t) => t.index < fromIndex);
+		if (kept.length === this.buffer.length) return;
+		this.buffer = kept;
+		this.phonemeCount = 0;
+		if (this.buffer.length === 0) {
+			this.firstTokenAtMs = 0;
+		}
+		if (this.chunkOn === "phoneme-stream" && this.tokenizer !== null) {
+			for (const t of this.buffer) {
+				this.phonemeCount += this.tokenizer.tokenize(t.text, t.index).length;
+			}
+		}
+	}
+
+	reset(): void {
+		this.buffer = [];
+		this.phonemeCount = 0;
+		this.firstTokenAtMs = 0;
+		this.phrasesEmitted = 0;
+	}
+
+	private endsWithTerminator(text: string): boolean {
+		if (text.length === 0) return false;
+		const last = text[text.length - 1];
+		return this.terminators.has(last);
+	}
+
+	private flushAs(terminator: Phrase["terminator"]): Phrase {
+		const tokens = this.buffer;
+		this.buffer = [];
+		this.phonemeCount = 0;
+		this.firstTokenAtMs = 0;
+		this.phrasesEmitted++;
+		const fromIndex = tokens[0].index;
+		const toIndex = tokens[tokens.length - 1].index;
+		const text = tokens.map((t) => t.text).join("");
+		const phrase: Phrase = {
+			id: this.nextPhraseId++,
+			text,
+			fromIndex,
+			toIndex,
+			terminator,
+		};
+		return phrase;
+	}
+}
+
+export function chunkTokens(
+	tokens: TextToken[],
+	config: PhraseChunkerConfig,
+	acceptedAt = 0,
+	tokenizer: PhonemeTokenizer | null = null,
+): Phrase[] {
+	const chunker = new PhraseChunker(config, tokenizer);
+	const phrases: Phrase[] = [];
+	for (const t of tokens) {
+		const p = chunker.push({ ...t, acceptedAt });
+		if (p) phrases.push(p);
+	}
+	const tail = chunker.flushPending();
+	if (tail) phrases.push(tail);
+	return phrases;
+}

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

@@ -0,0 +1,151 @@
+/**
+ * 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 { type DraftProposer, type TargetVerifier } from "./pipeline";
+import type { PcmFrame, StreamingTranscriber, TextToken, TranscriptUpdate, VerifierStreamEvent } from "./types";
+/**
+ * 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 declare class MissingAsrTranscriber implements StreamingTranscriber {
+    private readonly reason;
+    constructor(reason: string);
+    feed(_frame: PcmFrame): void;
+    flush(): Promise<TranscriptUpdate>;
+    on(): () => void;
+    dispose(): void;
+}
+/**
+ * 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 declare function mtpTextRunner(runner: {
+    mtpEnabled(): boolean;
+    generateWithUsage(args: GenerateArgs & {
+        onVerifierEvent: (event: VerifierStreamEvent) => void | Promise<void>;
+    }): Promise<{
+        text: string;
+    }>;
+}): MtpTextRunner;
+/**
+ * `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 declare class MtpDraftProposer implements DraftProposer {
+    private readonly runner;
+    constructor(runner: MtpTextRunner);
+    propose(args: {
+        prefix: ReadonlyArray<TextToken>;
+        maxDraft: number;
+        cancel: {
+            cancelled: boolean;
+        };
+    }): Promise<TextToken[]>;
+}
+/**
+ * `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 declare class MtpTargetVerifier implements TargetVerifier {
+    private readonly runner;
+    private readonly maxStep;
+    constructor(runner: MtpTextRunner, opts?: {
+        maxStep?: number;
+    });
+    verify(args: {
+        prefix: ReadonlyArray<TextToken>;
+        draft: ReadonlyArray<TextToken>;
+        cancel: {
+            cancelled: boolean;
+        };
+    }): Promise<{
+        accepted: TextToken[];
+        done: boolean;
+    }>;
+}
+/**
+ * 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;
+}
+//# sourceMappingURL=pipeline-impls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline-impls.d.ts","sourceRoot":"","sources":["pipeline-impls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C,OAAO,EACN,KAAK,aAAa,EAElB,KAAK,cAAc,EACnB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EACX,QAAQ,EACR,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EAChB,mBAAmB,EACnB,MAAM,SAAS,CAAC;AAMjB;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,YAAW,oBAAoB;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAAN,MAAM,EAAE,MAAM;IAC3C,IAAI,CAAC,MAAM,EAAE,QAAQ,GAAG,IAAI;IAGtB,KAAK,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAGxC,EAAE,IAAI,MAAM,IAAI;IAGhB,OAAO,IAAI,IAAI;CACf;AAMD;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC7B,qDAAqD;IACrD,UAAU,IAAI,OAAO,CAAC;IACtB,0BAA0B,CACzB,IAAI,EAAE,YAAY,GAAG;QACpB,eAAe,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACtE,GACC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7B;AAED,4DAA4D;AAC5D,wBAAgB,aAAa,CAAC,MAAM,EAAE;IACrC,UAAU,IAAI,OAAO,CAAC;IACtB,iBAAiB,CAChB,IAAI,EAAE,YAAY,GAAG;QACpB,eAAe,EAAE,CAAC,KAAK,EAAE,mBAAmB,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACtE,GACC,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC7B,GAAG,aAAa,CAUhB;AAaD;;;;;;;;;;;;;;GAcG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IACrD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;gBAE3B,MAAM,EAAE,aAAa;IAI3B,OAAO,CAAC,IAAI,EAAE;QACnB,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;QACjC,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE;YAAE,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;KAC/B,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;CA6BxB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,iBAAkB,YAAW,cAAc;IACvD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,MAAM,EAAE,aAAa,EAAE,IAAI,GAAE;QAAE,OAAO,CAAC,EAAE,MAAM,CAAA;KAAO;IAK5D,MAAM,CAAC,IAAI,EAAE;QAClB,MAAM,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;QACjC,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,CAAC;QAChC,MAAM,EAAE;YAAE,SAAS,EAAE,OAAO,CAAA;SAAE,CAAC;KAC/B,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,SAAS,EAAE,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAE,CAAC;CA2CrD;AAMD;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,qBAAqB;IACrC,SAAS,EAAE,OAAO,CAAC;IACnB;;;;OAIG;IACH,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,KAAK,MAAM,IAAI,CAAC;CAChD"}