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

package/src/services/voice/engine-bridge.ts

@@ -78,6 +78,7 @@ import {
 } from "./pipeline-impls";
 import type { VoiceProfileStore } from "./profile-store";
 import { type SchedulerEvents, VoiceScheduler } from "./scheduler";
+import { AgentSelfVoiceImprint } from "./self-voice-imprint";
 import {
 	type MmapRegionHandle,
 	SharedResourceRegistry,
@@ -120,6 +121,7 @@ import type {
 	TranscriptionAudio,
 	VadEventSource,
 } from "./types";
+import { decodeMonoPcm16Wav, encodeMonoPcm16Wav } from "./wav-codec";
 
 const SAMPLE_RATE_DEFAULT = 24_000;
 const RING_BUFFER_CAPACITY_DEFAULT = SAMPLE_RATE_DEFAULT * 4; // 4s
@@ -605,7 +607,7 @@ export interface EngineVoiceBridgeOptions {
 	/**
 	 * Override only the TTS backend while keeping the fused bundle lifecycle
 	 * and ASR FFI loaded. Used when a bundle falls back from OmniVoice speech
-	 * to Kokoro speech but still needs bundled Qwen3-ASR for mic input.
+	 * to Kokoro speech but still needs bundled Gemma ASR for mic input.
 	 */
 	ttsBackendOverride?: OmniVoiceBackend;
 	/** Optional speaker preset paired with `ttsBackendOverride`. */
@@ -820,13 +822,25 @@ function isEventRuntime(
  * Flatten the (possibly lazy) `LiveAttributionConfig` into the plain options
  * the runtime helper consumes. Resolved per turn so a changing household roster
  * is picked up without re-arming voice.
+ *
+ * `transcript` is the turn's joined ASR text. The in-process engine owns ASR, so
+ * it threads the real transcript through to `handleLiveVoiceAttribution` — the
+ * merge engine's live name/partner extraction (`VoiceObserver.ingestTurn`) needs
+ * *what* was said, not just *who* said it (#8786). When empty it is omitted, so
+ * the helper falls back to "" exactly as before and diarization-only callers are
+ * unaffected.
  */
-function resolveLiveAttributionOptions(cfg: LiveAttributionConfig | null): {
+function resolveLiveAttributionOptions(
+	cfg: LiveAttributionConfig | null,
+	transcript = "",
+): {
 	ownerEntityId?: string | null;
 	knownSpeakerEntityIds?: readonly string[];
 	wakeWordActive?: boolean;
+	transcript?: string;
 } {
-	if (!cfg) return {};
+	const transcriptOpt = transcript !== "" ? { transcript } : {};
+	if (!cfg) return transcriptOpt;
 	const ownerEntityId =
 		typeof cfg.ownerEntityId === "function"
 			? cfg.ownerEntityId()
@@ -843,6 +857,7 @@ function resolveLiveAttributionOptions(cfg: LiveAttributionConfig | null): {
 		...(ownerEntityId !== undefined ? { ownerEntityId } : {}),
 		...(knownSpeakerEntityIds !== undefined ? { knownSpeakerEntityIds } : {}),
 		...(wakeWordActive !== undefined ? { wakeWordActive } : {}),
+		...transcriptOpt,
 	};
 }
 
@@ -946,6 +961,7 @@ export class EngineVoiceBridge {
 		asrAvailable: boolean,
 		phraseCache: PhraseCache,
 		attributionPipeline: VoiceAttributionPipeline | null = null,
+		private readonly selfVoiceImprint: AgentSelfVoiceImprint | null = null,
 		cancellationCoordinator: VoiceCancellationCoordinator | null = null,
 		optimisticGenerationPolicy: OptimisticGenerationPolicy | null = null,
 		eventRuntime: IAgentRuntime | null = null,
@@ -1133,12 +1149,30 @@ export class EngineVoiceBridge {
 		};
 
 		const sinkOverride = opts.sink;
+		let selfVoiceImprint: AgentSelfVoiceImprint | null = null;
+		const schedulerEvents: SchedulerEvents = {
+			...(opts.events ?? {}),
+			onAudio(chunk) {
+				opts.events?.onAudio?.(chunk);
+				if (!selfVoiceImprint) return;
+				void selfVoiceImprint
+					.observeAudio(chunk.pcm, chunk.sampleRate)
+					.catch((err: unknown) => {
+						logger.warn(
+							{
+								error: err instanceof Error ? err.message : String(err),
+							},
+							"[voice-bridge] agent self-voice imprint update failed",
+						);
+					});
+			},
+		};
 		const scheduler = new VoiceScheduler(
 			config,
 			sinkOverride
 				? { backend, sink: sinkOverride, phraseCache }
 				: { backend, phraseCache },
-			opts.events ?? {},
+			schedulerEvents,
 		);
 
 		// Wire the voice lifecycle. The lifecycle starts in `voice-off` —
@@ -1150,7 +1184,9 @@ export class EngineVoiceBridge {
 		const registry = opts.sharedResources ?? new SharedResourceRegistry();
 		const loaders =
 			opts.lifecycleLoaders ??
-			defaultLifecycleLoaders(opts.bundleRoot, ffiHandle, ffiContextRef);
+			defaultLifecycleLoaders(opts.bundleRoot, ffiHandle, ffiContextRef, {
+				skipTtsRegion: Boolean(opts.ttsBackendOverride),
+			});
 		const lifecycle = new VoiceLifecycle({ registry, loaders });
 
 		// Wire speaker-attribution when a profile store is provided. The
@@ -1208,6 +1244,9 @@ export class EngineVoiceBridge {
 					await resolvedEncoder?.dispose();
 				},
 			};
+			selfVoiceImprint = new AgentSelfVoiceImprint({
+				encoder: lazyEncoder,
+			});
 			// Fused diarizer (optional). When the build does not advertise the
 			// diarizer ABI, attribution runs without it — a single-speaker turn
 			// collapses to one segment (the attribution-pipeline localSpeakerId=0
@@ -1265,6 +1304,7 @@ export class EngineVoiceBridge {
 			asrAvailable,
 			phraseCache,
 			attributionPipeline,
+			selfVoiceImprint,
 			wiring?.coordinator ?? null,
 			wiring?.policy ?? null,
 			isEventRuntime(opts.runtime) ? opts.runtime : null,
@@ -1359,6 +1399,7 @@ export class EngineVoiceBridge {
 			false, // ASR is not served from this path
 			phraseCache,
 			null, // no profile store on Kokoro-only
+			null, // no self-voice imprint without live attribution
 			wiring?.coordinator ?? null,
 			wiring?.policy ?? null,
 		);
@@ -1743,6 +1784,7 @@ export class EngineVoiceBridge {
 	async transcribePcm(
 		args: TranscriptionAudio,
 		signal?: AbortSignal,
+		onPartial?: (delta: string) => void,
 	): Promise<string> {
 		this.assertVoiceOn("transcribe audio");
 		if (signal?.aborted) {
@@ -1750,6 +1792,54 @@ export class EngineVoiceBridge {
 				? signal.reason
 				: new DOMException("Aborted", "AbortError");
 		}
+		// Streaming path: when the caller wants partial transcripts (the
+		// TRANSCRIPTION model handler forwards the runtime's onStreamChunk here),
+		// drive the fused streaming-ASR session and emit each running partial as a
+		// delta — the same per-token pipe as chat text. Feed in ~1s windows so the
+		// decode surfaces partials progressively. Degrades gracefully: when the
+		// fused build's streaming-ASR decoder is a stub, createStreamingTranscriber
+		// resolves the fused batch adapter and the final transcript is emitted once.
+		if (onPartial) {
+			const transcriber = this.createStreamingTranscriber();
+			let shown = 0;
+			const emit = (full: string): void => {
+				if (typeof full === "string" && full.length > shown) {
+					const delta = full.slice(shown);
+					shown = full.length;
+					onPartial(delta);
+				}
+			};
+			const unsub = transcriber.on((ev) => {
+				if (ev.kind === "partial" || ev.kind === "final") {
+					emit(ev.update.partial);
+				}
+			});
+			const abort = () => transcriber.dispose();
+			try {
+				signal?.addEventListener("abort", abort, { once: true });
+				const win = Math.max(1600, Math.round(args.sampleRate));
+				for (let off = 0; off < args.pcm.length; off += win) {
+					if (signal?.aborted) break;
+					transcriber.feed({
+						pcm: args.pcm.subarray(off, Math.min(off + win, args.pcm.length)),
+						sampleRate: args.sampleRate,
+						timestampMs: Math.round((off / args.sampleRate) * 1000),
+					});
+				}
+				const final = await transcriber.flush();
+				emit(final.partial);
+				if (signal?.aborted) {
+					throw signal.reason instanceof Error
+						? signal.reason
+						: new DOMException("Aborted", "AbortError");
+				}
+				return final.partial;
+			} finally {
+				unsub();
+				signal?.removeEventListener("abort", abort);
+				transcriber.dispose();
+			}
+		}
 		const backendBatch = this.backend as OmniVoiceBackend & {
 			transcribe?: (args: TranscriptionAudio) => Promise<string>;
 		};
@@ -1833,6 +1923,26 @@ export class EngineVoiceBridge {
 		events?: VoiceTurnEvents,
 	): Promise<"done" | "token-cap" | "cancelled"> {
 		this.assertVoiceOn("run a voice turn");
+		// The turn's ASR transcript materializes inside `pipeline.run` (the
+		// `onAsrComplete` event) while attribution runs in parallel, so the two
+		// have to be correlated. `transcriptReady` resolves with the joined ASR
+		// text the instant ASR finalizes; the attribution `.then` awaits it before
+		// emitting `VOICE_TURN_OBSERVED` so the merge engine sees *what* was said,
+		// not just *who* said it (#8786). The pipeline's `finally` resolves it with
+		// the captured text (or "") so a cancelled/no-ASR turn never hangs the await.
+		let asrTranscript = "";
+		let resolveTranscript: (text: string) => void = () => {};
+		const transcriptReady = new Promise<string>((resolve) => {
+			resolveTranscript = resolve;
+		});
+		const turnEvents: VoiceTurnEvents = {
+			...events,
+			onAsrComplete(tokens) {
+				asrTranscript = tokens.map((t) => t.text).join("");
+				resolveTranscript(asrTranscript);
+				events?.onAsrComplete?.(tokens);
+			},
+		};
 		// If a profileStore was wired, kick off speaker-attribution in parallel
 		// with ASR. The attribution uses the same PCM buffer as the transcriber
 		// but runs through the diarizer + encoder + profile-store independently.
@@ -1840,9 +1950,9 @@ export class EngineVoiceBridge {
 		// arrives via `onAttribution` asynchronously (possibly after onComplete).
 		if (
 			this.attributionPipeline &&
-			(events?.onAttribution || this.eventRuntime)
+			(turnEvents.onAttribution || this.eventRuntime)
 		) {
-			const onAttribution = events?.onAttribution;
+			const onAttribution = turnEvents.onAttribution;
 			const attribution = this.attributionPipeline;
 			const eventRuntime = this.eventRuntime;
 			const liveAttribution = this.liveAttribution;
@@ -1859,14 +1969,23 @@ export class EngineVoiceBridge {
 					// output to the caller. Any caller with a profileStore +
 					// runtime gets diarization-driven gating for free.
 					if (eventRuntime) {
+						const transcript = await transcriptReady;
 						const { handleLiveVoiceAttribution } = await import(
 							"../../runtime/voice-entity-binding.js"
 						);
-						await handleLiveVoiceAttribution(
-							eventRuntime,
-							output,
-							resolveLiveAttributionOptions(liveAttribution),
-						);
+						const selfVoiceSimilarity =
+							output.observation?.embedding && this.selfVoiceImprint
+								? await this.selfVoiceImprint.similarity(
+										output.observation.embedding,
+									)
+								: null;
+						await handleLiveVoiceAttribution(eventRuntime, output, {
+							...resolveLiveAttributionOptions(liveAttribution, transcript),
+							agentSpeaking: this.scheduler.bargeIn.isAgentSpeaking,
+							...(typeof selfVoiceSimilarity === "number"
+								? { selfVoiceSimilarity }
+								: {}),
+						});
 					}
 					onAttribution?.(output);
 				})
@@ -1881,11 +2000,14 @@ export class EngineVoiceBridge {
 					);
 				});
 		}
-		const pipeline = this.buildPipeline(textRunner, config, events);
+		const pipeline = this.buildPipeline(textRunner, config, turnEvents);
 		this.activePipeline = pipeline;
 		try {
 			return await pipeline.run(audio);
 		} finally {
+			// Settle the transcript promise so a cancelled/no-ASR turn (where
+			// `onAsrComplete` never fired) cannot leave the attribution await pending.
+			resolveTranscript(asrTranscript);
 			if (this.activePipeline === pipeline) this.activePipeline = null;
 		}
 	}
@@ -1950,97 +2072,10 @@ export class EngineVoiceBridge {
 	}
 }
 
-export function encodeMonoPcm16Wav(
-	pcm: Float32Array,
-	sampleRate: number,
-): Uint8Array {
-	const channels = 1;
-	const bytesPerSample = 2;
-	const dataBytes = pcm.length * bytesPerSample;
-	const out = new Uint8Array(44 + dataBytes);
-	const view = new DataView(out.buffer);
-	writeAscii(out, 0, "RIFF");
-	view.setUint32(4, 36 + dataBytes, true);
-	writeAscii(out, 8, "WAVE");
-	writeAscii(out, 12, "fmt ");
-	view.setUint32(16, 16, true);
-	view.setUint16(20, 1, true);
-	view.setUint16(22, channels, true);
-	view.setUint32(24, sampleRate, true);
-	view.setUint32(28, sampleRate * channels * bytesPerSample, true);
-	view.setUint16(32, channels * bytesPerSample, true);
-	view.setUint16(34, bytesPerSample * 8, true);
-	writeAscii(out, 36, "data");
-	view.setUint32(40, dataBytes, true);
-
-	let offset = 44;
-	for (const sample of pcm) {
-		const clamped = Math.max(-1, Math.min(1, sample));
-		const value = clamped < 0 ? clamped * 0x8000 : clamped * 0x7fff;
-		view.setInt16(offset, Math.round(value), true);
-		offset += bytesPerSample;
-	}
-	return out;
-}
-
-export function decodeMonoPcm16Wav(bytes: Uint8Array): TranscriptionAudio {
-	if (bytes.byteLength < 44) {
-		throw new Error("[voice] WAV input is too short to contain a header");
-	}
-	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-	if (
-		readAscii(bytes, 0, 4) !== "RIFF" ||
-		readAscii(bytes, 8, 4) !== "WAVE" ||
-		readAscii(bytes, 12, 4) !== "fmt "
-	) {
-		throw new Error("[voice] Local transcription expects mono PCM16 WAV bytes");
-	}
-	const audioFormat = view.getUint16(20, true);
-	const channels = view.getUint16(22, true);
-	const sampleRate = view.getUint32(24, true);
-	const bitsPerSample = view.getUint16(34, true);
-	if (audioFormat !== 1 || channels !== 1 || bitsPerSample !== 16) {
-		throw new Error(
-			`[voice] Local transcription expects mono PCM16 WAV (format=1 channels=1 bits=16); got format=${audioFormat} channels=${channels} bits=${bitsPerSample}`,
-		);
-	}
-
-	let pos = 36;
-	while (pos + 8 <= bytes.byteLength) {
-		const chunkId = readAscii(bytes, pos, 4);
-		const chunkBytes = view.getUint32(pos + 4, true);
-		const dataStart = pos + 8;
-		if (chunkId === "data") {
-			if (dataStart + chunkBytes > bytes.byteLength) {
-				throw new Error("[voice] WAV data chunk exceeds input length");
-			}
-			if (chunkBytes % 2 !== 0) {
-				throw new Error("[voice] WAV PCM16 data chunk has odd byte length");
-			}
-			const pcm = new Float32Array(chunkBytes / 2);
-			for (let i = 0; i < pcm.length; i++) {
-				pcm[i] = view.getInt16(dataStart + i * 2, true) / 0x8000;
-			}
-			return { pcm, sampleRate };
-		}
-		pos = dataStart + chunkBytes + (chunkBytes % 2);
-	}
-	throw new Error("[voice] WAV input is missing a data chunk");
-}
-
-function writeAscii(out: Uint8Array, offset: number, text: string): void {
-	for (let i = 0; i < text.length; i++) {
-		out[offset + i] = text.charCodeAt(i);
-	}
-}
-
-function readAscii(bytes: Uint8Array, offset: number, length: number): string {
-	let out = "";
-	for (let i = 0; i < length; i++) {
-		out += String.fromCharCode(bytes[offset + i]);
-	}
-	return out;
-}
+// The mono PCM16 WAV codec lives in the dependency-light `wav-codec.ts` so
+// corpus / fixture / test code can encode + decode WAV without dragging in this
+// heavy module. Re-exported here for the existing callers.
+export { decodeMonoPcm16Wav, encodeMonoPcm16Wav };
 
 function readPositiveIntEnv(name: string): number | undefined {
 	const raw = process.env[name]?.trim();
@@ -2090,8 +2125,8 @@ function ensureContext(
  * `createStreamingTranscriber` directly (the fused-only chain in
  * `transcriber.ts`: fused streaming → fused batch → AsrUnavailableError).
  */
-function kokoroOnlyLifecycleLoaders(): VoiceLifecycleLoaders {
-	const noopMmap = (id: string): MmapRegionHandle => ({
+function noopMmapRegion(id: string): MmapRegionHandle {
+	return {
 		id,
 		path: "",
 		sizeBytes: 0,
@@ -2101,10 +2136,13 @@ function kokoroOnlyLifecycleLoaders(): VoiceLifecycleLoaders {
 		async release() {
 			// No mmap region to release.
 		},
-	});
+	};
+}
+
+function kokoroOnlyLifecycleLoaders(): VoiceLifecycleLoaders {
 	return {
-		loadTtsRegion: async () => noopMmap("kokoro:tts"),
-		loadAsrRegion: async () => noopMmap("kokoro:asr"),
+		loadTtsRegion: async () => noopMmapRegion("kokoro:tts"),
+		loadAsrRegion: async () => noopMmapRegion("kokoro:asr"),
 		loadVoiceCaches: async () => ({
 			id: "kokoro:voice-caches",
 			async release() {},
@@ -2120,10 +2158,13 @@ function defaultLifecycleLoaders(
 	bundleRoot: string,
 	ffi: ElizaInferenceFfi | null,
 	ctx: ElizaInferenceContextHandle | FfiContextRef | null,
+	options: { skipTtsRegion?: boolean } = {},
 ): VoiceLifecycleLoaders {
 	return {
 		loadTtsRegion: async () =>
-			bundleMmapRegion(path.join(bundleRoot, "tts"), "tts", ffi, ctx),
+			options.skipTtsRegion === true
+				? noopMmapRegion(`tts-override:${bundleRoot}`)
+				: bundleMmapRegion(path.join(bundleRoot, "tts"), "tts", ffi, ctx),
 		loadAsrRegion: async () =>
 			bundleMmapRegion(path.join(bundleRoot, "asr"), "asr", ffi, ctx),
 		loadVoiceCaches: async () => ({

package/src/services/voice/eot-classifier-ggml.ts

@@ -2,8 +2,8 @@
  * LiveKit turn-detector — GGUF-backed binding (J1.d).
  *
  * The text-side turn-completion classifier formats the latest partial
- * user transcript with the Qwen chat template, strips the trailing
- * `<|im_end|>`, and reads `P(<|im_end|>)` from the next-token
+ * user transcript with the Gemma chat template, strips the trailing
+ * `<end_of_turn>`, and reads `P(<end_of_turn>)` from the next-token
  * distribution. The upstream `livekit/turn-detector` ships an ONNX
  * graph; this binding consumes the **GGUF** export published at
  * `elizaos/eliza-1` under `voice/turn-detector/onnx/turn-detector-en-q8.gguf`
@@ -18,9 +18,9 @@
  * (`.swarm/impl/I1-single-runtime.md` §B), the turn-detector was the
  * cheapest of the four remaining ONNX surfaces to retire — the GGUF
  * artifact was already published by H4 (see commit history), and the
- * detector's architecture (Qwen2-style small decoder + classification
- * head on the `<|im_end|>` logit) is exactly what `LLM_ARCH_QWEN2`
- * already implements in the fork. The work is wiring, not porting.
+ * detector's architecture (a small decoder + classification head on the
+ * `<end_of_turn>` logit) is already implemented in the fork. The work is
+ * wiring, not porting.
  *
  * No silent fallback (AGENTS.md §3): when `capacitor-llama` is
  * unavailable, the GGUF is missing, or the model load fails, this
@@ -29,11 +29,11 @@
  * legacy ONNX path; the binding itself never fabricates a probability.
  *
  * Tokenizer ownership: the GGUF carries its own tokenizer (BPE +
- * special tokens, including `<|im_end|>`); this binding does NOT
+ * special tokens, including `<end_of_turn>`); this binding does NOT
  * import `@huggingface/transformers`. The `apply_chat_template`
  * formatting is re-implemented here using the same template upstream
- * uses (single-turn user message wrapped in `<|im_start|>user\n... \n`)
- * — see `applyQwenUserTemplate` below.
+ * uses (single-turn user message wrapped in `<start_of_turn>user\n... \n`)
+ * — see `applyGemmaUserTemplate` below.
  *
  * --- Planned LoRA hot-swap path ---
  *
@@ -41,7 +41,7 @@
  * model. The chat target model (eliza-1-{2b,4b}) is already
  * loaded for conversation — its next-token distribution after the
  * chat-template-formatted partial transcript provides exactly the
- * same `P(<|im_end|>)` signal. A LoRA adapter (rank 8, ~5-10 MB)
+ * same `P(<end_of_turn>)` signal. A LoRA adapter (rank 8, ~5-10 MB)
  * trained on `(transcript, eot_label)` pairs can shape that signal
  * to match or beat the LiveKit baseline.
  *
@@ -60,7 +60,7 @@
  *      LoRA hot-swap over standing up the LiveKit GGUF process.
  *   3. The hot-swap path uses llama.cpp's `--lora` flag on the chat
  *      target. A single forward pass against the chat-template-formatted
- *      transcript yields the next-token logits; read `<|im_end|>`'s
+ *      transcript yields the next-token logits; read `<end_of_turn>`'s
  *      probability and return it.
  *   4. Fail-closed: if adapter load fails or the SHA binding mismatches,
  *      throw `EotGgmlUnavailableError("model-load-failed", ...)`. No
@@ -87,7 +87,7 @@ export class EotGgmlUnavailableError extends Error {
 		| "native-missing"
 		| "model-missing"
 		| "model-load-failed"
-		| "tokenizer-missing-im-end"
+		| "tokenizer-missing-end-of-turn"
 		| "evaluate-failed"
 		| "invalid-input";
 	constructor(code: EotGgmlUnavailableError["code"], message: string) {
@@ -113,7 +113,7 @@ export const DEFAULT_LIVEKIT_TURN_DETECTOR_GGUF_INTL =
 	"voice/turn/intl/turn-detector-intl-q8.gguf";
 
 /** Special-token literal the detector reads the probability of. */
-export const LIVEKIT_IM_END_TOKEN = "<|im_end|>";
+export const LIVEKIT_END_OF_TURN_TOKEN = "<end_of_turn>";
 
 /**
  * Default on-disk location for the staged GGUF. The bundle downloader
@@ -263,7 +263,7 @@ export interface LiveKitGgmlTurnDetectorOptions {
 	 * `"v0.4.1-intl"`). Does not affect inference.
 	 */
 	revision?: string;
-	/** Max history tokens after Qwen-template wrapping. Default: 128. */
+	/** Max history tokens after Gemma-template wrapping. Default: 128. */
 	maxHistoryTokens?: number;
 	/** Optional model label for telemetry. */
 	model?: string;
@@ -277,8 +277,8 @@ export interface LiveKitGgmlTurnDetectorOptions {
 
 /**
  * Local GGUF-backed LiveKit turn-detector. Uses a `capacitor-llama`
- * evaluation of the Qwen2-style decoder, reading `P(<|im_end|>)` from the
- * next-token distribution after the truncated user-template prefix.
+ * evaluation of the decoder, reading `P(<end_of_turn>)` from the next-token
+ * distribution after the truncated user-template prefix.
  *
  * One detector instance owns one `LlamaModel` + one `LlamaContext` +
  * one `LlamaSequence`. `score()` resets the sequence between calls —
@@ -295,7 +295,7 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		llamaModel: NlcLlamaModel;
 		context: NlcLlamaContext;
 		sequence: NlcLlamaSequence;
-		imEndTokenId: number;
+		endOfTurnTokenId: number;
 	}> | null = null;
 
 	constructor(opts: LiveKitGgmlTurnDetectorOptions) {
@@ -325,14 +325,14 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		const loaded = await this.load();
 		const transcript = normalizeTurnDetectorText(partialTranscript);
 		// Tokenize the user-templated transcript WITHOUT the trailing
-		// `<|im_end|>` (the head must score that token as the next one).
+		// `<end_of_turn>` (the head must score that token as the next one).
 		// We do not pass `specialTokens=true` for the user text itself —
 		// only the template wrappers themselves are special tokens.
-		const promptText = applyQwenUserTemplate(transcript);
+		const promptText = applyGemmaUserTemplate(transcript);
 
 		// Tokenize: the template wrappers are special tokens; the GGUF's
 		// BPE handles the inner text. Passing `true` tells the tokenizer
-		// to recognize the `<|im_start|>` / `\n` literals as the real
+		// to recognize the `<start_of_turn>` / `\n` literals as the real
 		// special-token ids. Truncate from the LEFT so the recent text
 		// is preserved.
 		let tokens = loaded.llamaModel.tokenize(promptText, true);
@@ -351,7 +351,7 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		await loaded.sequence.clearHistory();
 
 		// Feed every token, asking for the probability distribution only
-		// on the LAST one. That gives us P(token=<|im_end|>) after the
+		// on the LAST one. That gives us P(token=<end_of_turn>) after the
 		// truncated template prefix.
 		const lastIdx = tokens.length - 1;
 		const input = tokens.map((tok, i) =>
@@ -371,10 +371,10 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 				"[eot-ggml] controlledEvaluate did not return probabilities for the last token",
 			);
 		}
-		const imEndProb = probs.get(loaded.imEndTokenId) ?? 0;
+		const endOfTurnProb = probs.get(loaded.endOfTurnTokenId) ?? 0;
 
 		return turnSignalFromProbability({
-			probability: imEndProb,
+			probability: endOfTurnProb,
 			transcript,
 			source: "livekit-turn-detector",
 			model: this.model,
@@ -398,7 +398,7 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		llamaModel: NlcLlamaModel;
 		context: NlcLlamaContext;
 		sequence: NlcLlamaSequence;
-		imEndTokenId: number;
+		endOfTurnTokenId: number;
 	}> {
 		this.ready ??= this.loadInner();
 		return this.ready;
@@ -408,7 +408,7 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		llamaModel: NlcLlamaModel;
 		context: NlcLlamaContext;
 		sequence: NlcLlamaSequence;
-		imEndTokenId: number;
+		endOfTurnTokenId: number;
 	}> {
 		try {
 			await access(this.ggufPath);
@@ -433,18 +433,21 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 			);
 		}
 
-		// Resolve the <|im_end|> token id from the GGUF's BPE tokenizer.
+		// Resolve the <end_of_turn> token id from the GGUF's BPE tokenizer.
 		// Passing `specialTokens=true` tells the tokenizer to recognize
 		// the literal as the corresponding special token.
-		const imEndTokens = llamaModel.tokenize(LIVEKIT_IM_END_TOKEN, true);
-		if (imEndTokens.length !== 1) {
+		const endOfTurnTokens = llamaModel.tokenize(
+			LIVEKIT_END_OF_TURN_TOKEN,
+			true,
+		);
+		if (endOfTurnTokens.length !== 1) {
 			await llamaModel.dispose().catch(() => undefined);
 			throw new EotGgmlUnavailableError(
-				"tokenizer-missing-im-end",
-				`[eot-ggml] tokenizer produced ${imEndTokens.length} tokens for <|im_end|>; expected exactly 1. The GGUF's special-token table is missing the expected entry.`,
+				"tokenizer-missing-end-of-turn",
+				`[eot-ggml] tokenizer produced ${endOfTurnTokens.length} tokens for <end_of_turn>; expected exactly 1. The GGUF's special-token table is missing the expected entry.`,
 			);
 		}
-		const imEndTokenId = imEndTokens[0];
+		const endOfTurnTokenId = endOfTurnTokens[0];
 
 		let context: NlcLlamaContext;
 		try {
@@ -461,7 +464,7 @@ export class LiveKitGgmlTurnDetector implements EotClassifier {
 		}
 
 		const sequence = context.getSequence();
-		return { llamaModel, context, sequence, imEndTokenId };
+		return { llamaModel, context, sequence, endOfTurnTokenId };
 	}
 }
 
@@ -550,17 +553,17 @@ function normalizeTurnDetectorText(text: string): string {
 }
 
 /**
- * Apply the single-turn user Qwen chat template, omitting the trailing
- * `<|im_end|>` so the detector head scores it as the next token.
+ * Apply the single-turn user Gemma chat template, omitting the trailing
+ * `<end_of_turn>` so the detector head scores it as the next token.
  *
  * Upstream `livekit/turn-detector` formats:
  *
- *   <|im_start|>user\n{transcript}<|im_end|>\n
+ *   <start_of_turn>user\n{transcript}<end_of_turn>\n
  *
- * The detector strips the trailing `<|im_end|>\n` and reads
- * `P(<|im_end|>)` after the user content. We emit the prefix exactly,
- * stopping where the `<|im_end|>` would go.
+ * The detector strips the trailing `<end_of_turn>\n` and reads
+ * `P(<end_of_turn>)` after the user content. We emit the prefix exactly,
+ * stopping where the `<end_of_turn>` would go.
  */
-export function applyQwenUserTemplate(transcript: string): string {
-	return `<|im_start|>user\n${transcript}`;
+export function applyGemmaUserTemplate(transcript: string): string {
+	return `<start_of_turn>user\n${transcript}`;
 }