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

package/src/services/vision/index.ts

@@ -119,7 +119,7 @@ export interface CreateVisionCapabilityRegistrationOptions {
 	 */
 	arbiterCache?: VisionEmbeddingCacheLike;
 	loader: VisionDescribeBackendLoader;
-	/** Default model family for the cache key. Defaults to `qwen3-vl`. */
+	/** Default model family for the cache key. Defaults to `gemma-vl`. */
 	modelFamily?: string;
 	estimatedMb?: number;
 }
@@ -138,7 +138,7 @@ export function createVisionCapabilityRegistration(
 	VisionDescribeResult
 > {
 	const capability: ArbiterCapability = "vision-describe";
-	const family = opts.modelFamily ?? "qwen3-vl";
+	const family = opts.modelFamily ?? "gemma-vl";
 	const cache = opts.arbiterCache;
 	const loader = opts.loader;
 	return {

package/src/services/vision/llama-server.ts

@@ -157,7 +157,7 @@ function buildVisionPrompt(userPrompt?: string): string {
 	// the encoded image tokens. The `N` must match the `image_data[*].id`
 	// we send in the body; we use 12 because llama-server's stock
 	// example uses small integer ids — any positive integer works.
-	return `<|im_start|>user\n[img-12]\n${ask}<|im_end|>\n<|im_start|>assistant\n`;
+	return `<start_of_turn>user\n[img-12]\n${ask}<end_of_turn>\n<start_of_turn>model\n`;
 }
 
 function shape(

package/src/services/vision/types.ts

@@ -46,8 +46,8 @@ export type VisionImageInput =
 /**
  * Caller request to `describeImage`. The `modelFamily` distinguishes
  * projected-token cache entries from different VL families that share
- * the same hash space — Qwen3-VL tokens are not interchangeable with
- * Florence-2 tokens. Default is `qwen3-vl` (the WS2 deliverable);
+ * the same hash space — Gemma-VL tokens are not interchangeable with
+ * Florence-2 tokens. Default is `gemma-vl` (the WS2 deliverable);
  * each additional family registers under its own identifier.
  */
 export interface VisionDescribeRequest {
@@ -56,7 +56,7 @@ export interface VisionDescribeRequest {
 	/**
 	 * The model family identifier. Used to namespace the projector cache
 	 * so swapping the backend's model family invalidates cached tokens.
-	 * Defaults to `"qwen3-vl"` when omitted.
+	 * Defaults to `"gemma-vl"` when omitted.
 	 */
 	modelFamily?: string;
 	/** Max output tokens; defaults to 256 (description-length budget). */
@@ -64,6 +64,15 @@ export interface VisionDescribeRequest {
 	/** 0..1, default 0.2 (descriptions should be deterministic-ish). */
 	temperature?: number;
 	signal?: AbortSignal;
+	/**
+	 * Per-token callback. When set and the backend exposes streaming vision
+	 * (the fused ABI-v13 path), the description is decoded token-by-token and
+	 * each piece is delivered here as it generates — the same pipe as chat text.
+	 * Backends without streaming describe ignore it and return the final result.
+	 */
+	onTextChunk?: (chunk: string) => void | Promise<void>;
+	/** Per-step token cap for streaming describe (smaller = finer-grained UI). */
+	maxTokensPerStep?: number;
 }
 
 /** Backend response — same shape that ImageDescriptionResult expects. */
@@ -145,7 +154,7 @@ export interface VisionDescribeBackendOptions {
 
 /**
  * Capability handler load function. The arbiter calls it with a model
- * key (e.g. `"qwen3-vl-2b"`); the implementation resolves to a real
+ * key (e.g. `"gemma-vl-4b"`); the implementation resolves to a real
  * `(modelPath, mmprojPath)` pair from the catalog + installed registry
  * and returns a live backend.
  */

package/src/services/vision-embedding-cache.ts

@@ -1,7 +1,7 @@
 /**
  * Content-hashed cache for projected vision-language tokens (WS1 deliverable).
  *
- * Vision models in the Eliza-1 stack (Qwen3-VL, Florence-2, Apothic-VL) all
+ * Vision models in the Eliza-1 stack (Gemma-VL, Florence-2, Apothic-VL) all
  * go through the same expensive projector step: raw pixel
  * bytes → patch embeddings → projector → tokens that the text decoder
  * actually consumes. When the user pastes the same screenshot three times

package/src/services/voice/VOICE_WORKBENCH.md

@@ -9,13 +9,35 @@ format, no shared corpus, divergent metric definitions, and a headful surface
 that only covered a single-speaker, single-turn round-trip. The Voice Workbench
 unifies them onto **one scenario format, one metric module, and one report**.
 
+> **Capability assessment + evidence map** (what is CI-proven vs hardware/
+> credential-gated, mapped to every #8785 AC and the product-owner questions):
+> [research/VOICE_8785_ASSESSMENT.md](./research/VOICE_8785_ASSESSMENT.md).
+> Research evidence base (pause lengths, VAD, AEC, diarization, owner verification,
+> model landscape, latency math): [research/VOICE_PIPELINE_RESEARCH_2026.md](./research/VOICE_PIPELINE_RESEARCH_2026.md).
+
 ## Status
 
-This directory holds the **pure, framework-level foundation** — the parts that
-can be implemented, tested, and shipped without an audio corpus, native models,
-or a browser. The execution runners that actually drive real services/audio are
-intentionally **gated** (they need a provisioned Eliza-1 local backend + a
-synthesized corpus) and are listed under *Remaining* below.
+The schema, corpus generator (incl. acoustic degradation), metric module,
+headless runner, report, scenario-runner `voice` turn kind, headful scenario
+player, and the `voice:workbench` CLI are all **implemented and unit-tested**.
+The real **acoustic-model** lane (`--real`) is implemented as a provisioned
+hardware lane: it generates distinct human voices with ElevenLabs, synthesizes
+agent echoes with the fused local TTS, and scores the corpus through fused ASR,
+WeSpeaker, pyannote, and the shipped respond/self-voice gate. Missing real
+artifacts are a hard failure in `--real`, not all-skipped evidence.
+
+### Execution lanes (`voice:workbench`)
+
+| Lane | Services | Proves | CI |
+| --- | --- | --- | --- |
+| `--mock` (default) | `groundTruthMockServices` echoes ground truth | runner → scorers → report wiring | ✅ always |
+| `--logic` | `realDecisionLogicServices` runs the SHIPPED EOT + respond/echo/bystander/wake-word gate + name extraction + owner inference | the **decision logic** (catches a regression the moment it lands) | ✅ always (no models) |
+| `--real` | ElevenLabs human speech + fused local TTS/ASR + WeSpeaker + pyannote | real WER/DER/EOT/respond/self-voice/owner-security measurements | ✅ provisioned nightly/hardware lane |
+
+The `--logic` lane is the key anti-hollow guarantee: it does NOT echo the corpus,
+it runs the same gate the UI client ships (`@elizaos/shared/voice/respond-gate`),
+so the workbench genuinely suppresses a bystander, rejects the agent's echoed
+reply, and holds on a mid-utterance pause — asserted by tests, not assumed.
 
 ### Implemented (this directory, unit-tested, no native artifacts)
 
@@ -25,9 +47,26 @@ synthesized corpus) and are listed under *Remaining* below.
 | **Metric module (single source of truth)** | `e2e-harness.ts` | All voice scoring lives here. WER is delegated to `@elizaos/shared/voice-wer` (one definition for headless + headful). Added scorers: `scoreEotDecision` (latency p50/p95 + false-trigger/false-suppression rate), `scoreRespondDecision` (FP/FN split), `scoreDiarization` (DER + confusions/misses), `scoreEntityExtraction` (precision/recall/F1), `scoreVoiceEntityMatch` (recognized-voice→entity accuracy). |
 | **Benchmark report** | `voice-workbench-report.ts` | `buildVoiceWorkbenchReport` rolls a matrix of per-scenario scorer results into one gating report (per-metric mean/worst + percentiles, per-scenario verdict). `formatVoiceWorkbenchMarkdown` renders it; `regressionsAgainstBaseline` flags metrics that worsened past a tolerance. |
 | **WER consolidation** | `@elizaos/shared/voice-wer` | The previously-duplicated `wordErrorRate` (`e2e-harness.ts` **and** `voice-selftest-harness.ts`, with subtly different normalization) is now defined once — Unicode-aware, contraction-preserving — and imported by both. |
+| **Acoustic robustness corpus** | `corpus-augment.ts` | Seeded, deterministic degradation DSP: additive room noise (white/pink at a target SNR), Freeverb reverb, far-field attenuation, telephone/low-quality line (band-limit + µ-law), and competing background talkers. Wired into the corpus generator via a per-turn / per-scenario `environment` so a clean scenario and a noisy one share one schema. |
+| **Real-decision-logic adapter** | `workbench-logic-services.ts` | Runs the SHIPPED EOT + respond/echo/bystander/wake-word gate + name extraction over the corpus (no models). The `--logic` lane. |
+| **Real acoustic adapter** | `workbench-real-services.ts` | The `--real` lane: ElevenLabs-generated human speech, fused local agent TTS, fused ASR, WeSpeaker speaker centroids, pyannote speech/overlap labels, live `selfVoiceSimilarity`, owner inference, and the same respond gate. |
+| **Respond/echo gate (single source)** | `@elizaos/shared/voice/respond-gate` | `shouldRespondToVoiceTurn` + `buildVoiceTurnSignal`, promoted out of the UI so the client and the workbench share one definition. The UI re-exports it. |
+| **Owner inference** | `@elizaos/shared/voice/owner-inference` | `resolveOwnerCandidate` — proposes the owner from who speaks most/most-confidently, only when sufficient AND unambiguous, else UNDECIDED. The logic an owner-detection provider/evaluator runs when no owner is enrolled. |
+| **Echo + owner scorers** | `e2e-harness.ts` | `scoreEchoRejection` (agent-echo turns correctly suppressed) and `scoreOwnerSecurity` (owner-vs-intruder accuracy + impostor-accept rate). |
 
 Tests: `voice-workbench.test.ts`, `voice-workbench-report.test.ts`,
-`e2e-harness.test.ts`.
+`e2e-harness.test.ts`, `corpus-augment.test.ts`,
+`workbench-logic-services.test.ts`, `corpus-generator.test.ts`, and (in shared)
+`voice/owner-inference.test.ts`.
+
+### Scenario classes
+
+`multi-voice`, `pauses`, `respond-no-respond`, `multi-speaker`, `diarization`,
+`entity-extraction`, `voice-recognition`, `eot`, `transcription-mode`,
+`multi-agent-room`, `long-form-monologue`, **`robustness`** (noise / reverb /
+far-field / low-quality), **`echo-rejection`** (agent self-voice), **`owner-security`**
+(owner vs intruder), **`overlapping-speech`** (interrupting talkers). The 12
+built-in scenarios in `workbench-scenarios.ts` span every class.
 
 ### Honesty contract
 
@@ -63,26 +102,32 @@ The workbench is the convergence point for these previously-disjoint harnesses:
 | `e2e-harness.ts:wordErrorRate` + `voice-selftest-harness.ts:wordErrorRate` | **Done** — one `@elizaos/shared/voice-wer`. |
 | Pure scoring lib (`e2e-harness.ts`) | **Promoted** to the single metric module (EOT/diarization/respond/entity scorers added). |
 | `packages/app-core/scripts/voice-duet.mjs` (`voice:duet`), `voice-e2e-hardware.ts`, `voice-vad-smoke.ts`, `voice-attribution-smoke.ts`, `lib/duet-bridge.mjs` | Feed measurements into the shared scorers + report (planned absorb). |
-| `packages/benchmarks/voice/three-voice-scenario.mjs`, `three-voice-e2e-real.mjs` | Corpus-generation precedent the `VoiceScenario` corpus generator extends (planned). |
+| `packages/benchmarks/voice/three-voice-scenario.mjs` | Corpus-generation precedent the `VoiceScenario` corpus generator extends (planned). |
 | `packages/benchmarks/voicebench/` (TS latency p95/p99) | The report layer mirrors its p95/p99 shape; remains a research bench linked from the workbench. |
 | Per-spec inline `tinyWav()` fixtures (`packages/app/test/ui-smoke/voice-*.spec.ts`) | Replaced by the versioned corpus (planned). |
 
-## Remaining (gated — needs corpus + real backend)
-
-These are tracked on #8785 and are **not** stubbed here (no LARP):
-
-- **Corpus generator + versioned labeled corpus** — TTS-synthesize each turn,
-  splice pauses, mix multi-speaker streams; persist labeled WAV + ground-truth
-  JSON. Needs the real TTS routes / Kokoro voices. (`__test-helpers__/synthetic-speech.ts`
-  is the synthesis seed.)
-- **Headless runner** — wire the scenario through the real ASR/diarization/EOT/
-  respond/entity/TTS services + `AgentRuntime`.
-- **scenario-runner audio turn kind** — add an `audio`/`voice` `ScenarioTurnExecution`
-  so voice scenarios become first-class `.scenario.ts` files.
-- **Headful scenario player** — `VoiceSelfTestShell` → multi-turn player +
-  `packages/app/test/ui-smoke/voice-workbench-*.spec.ts` per scenario class.
-- **`voice:workbench` entrypoint + CI lane** — run the matrix, emit the report
-  (`buildVoiceWorkbenchReport`), `skipped` (never `pass`) when artifacts absent.
-- **Multi-agent room semantics** — the canonical ≥3-participant "who responds"
-  contract (an open question on the issue) must be settled before the workbench
-  can assert against it rather than inventing a rule.
+## External / Device Follow-Ups
+
+Full detail + why in
+[research/VOICE_8785_ASSESSMENT.md §5](./research/VOICE_8785_ASSESSMENT.md).
+
+- **Live cloud STT/TTS round-trip** — ElevenLabs via `/api/v1/voice/*`; needs an
+  authenticated Cloud session (the test account returns HTTP 402 — a billing
+  state, not a code bug).
+- **PCM-level AEC** — still a product/runtime feature beyond the workbench
+  scorer: it needs a time-aligned playback reference and cancellation path in
+  the live audio transport, then the workbench can score the resulting echo
+  corpus.
+- **Headful real-backend + recorded A/V** — the 10 `voice-workbench-*.spec.ts`
+  run with mocked backends; a real-backend headful lane with audio+video capture
+  needs a provisioned local backend on the CI host.
+- **iOS device** — blocked on Apple ID provisioning; simulator local-inference is
+  Metal-limited.
+
+## Open follow-up: PCM-level acoustic echo cancellation
+
+Self-echo is caught at the transcript level only (word overlap). The recommended
+next step is an `agentSpeaking` flag + ~1.5 s post-TTS cooldown (cheap, robust),
+then WebRTC AEC3 with a time-aligned reference, then speaker-embedding self-voice
+rejection. The `scoreEchoRejection` scorer is ready to gate it. See
+[research/VOICE_8785_ASSESSMENT.md §6](./research/VOICE_8785_ASSESSMENT.md).

package/src/services/voice/__fixtures__/voice-workbench-logic-baseline.json

@@ -0,0 +1,180 @@
+{
+	"schemaVersion": 1,
+	"overall": "pass",
+	"scenariosTotal": 14,
+	"scenariosRan": 14,
+	"scenariosSkipped": 0,
+	"scenarios": [
+		{
+			"scenarioId": "multi-voice-greeting",
+			"classes": ["multi-voice", "diarization"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 8,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "respond-vs-bystander",
+			"classes": ["respond-no-respond", "multi-speaker"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 9,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "pauses-midutterance",
+			"classes": ["pauses", "eot"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 7,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "entity-from-speech",
+			"classes": ["entity-extraction", "voice-recognition"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 7,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "transcription-mode-dictation",
+			"classes": ["transcription-mode", "long-form-monologue"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 5,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "multi-agent-room-address",
+			"classes": ["multi-agent-room", "respond-no-respond"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 8,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "noisy-room-commands",
+			"classes": ["robustness", "respond-no-respond"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 8,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "far-field-reverb",
+			"classes": ["robustness", "respond-no-respond"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 6,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "background-talkers",
+			"classes": ["robustness", "overlapping-speech", "multi-speaker"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 6,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "echo-self-trigger",
+			"classes": ["echo-rejection", "respond-no-respond"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 10,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "multi-speaker-name-capture",
+			"classes": [
+				"diarization",
+				"entity-extraction",
+				"multi-speaker",
+				"voice-recognition"
+			],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 13,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "echo-mistranscribed",
+			"classes": ["echo-rejection"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 8,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "owner-enrollment-inference",
+			"classes": ["owner-security", "voice-recognition"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 15,
+			"failedCaseKinds": []
+		},
+		{
+			"scenarioId": "owner-vs-intruder",
+			"classes": ["owner-security", "respond-no-respond", "multi-speaker"],
+			"status": "ran",
+			"verdict": "pass",
+			"caseCount": 10,
+			"failedCaseKinds": []
+		}
+	],
+	"metrics": {
+		"wer": {
+			"count": 32,
+			"mean": 0,
+			"worst": 0
+		},
+		"eotFalseTriggerRate": {
+			"count": 14,
+			"mean": 0,
+			"worst": 0
+		},
+		"eotLatencyP50Ms": null,
+		"eotLatencyP95Ms": null,
+		"der": {
+			"count": 14,
+			"mean": 0,
+			"worst": 0
+		},
+		"respondAccuracy": {
+			"count": 14,
+			"mean": 1,
+			"worst": 1
+		},
+		"entityF1": {
+			"count": 2,
+			"mean": 1,
+			"worst": 1
+		},
+		"voiceEntityMatchRate": {
+			"count": 14,
+			"mean": 1,
+			"worst": 1
+		},
+		"firstAudioMs": {
+			"count": 26,
+			"mean": 250,
+			"worst": 250
+		},
+		"echoRejectionRate": {
+			"count": 2,
+			"mean": 1,
+			"worst": 1
+		},
+		"ownerAccuracy": {
+			"count": 2,
+			"mean": 1,
+			"worst": 1
+		},
+		"impostorAcceptRate": {
+			"count": 2,
+			"mean": 0,
+			"worst": 0
+		}
+	}
+}

package/src/services/voice/__test-helpers__/synthetic-speech.ts

@@ -21,6 +21,21 @@ export interface SpeechFixtureOptions {
 	tailSilenceSec?: number;
 	/** Deterministic seed for the f0 jitter. */
 	seed?: number;
+	/**
+	 * Per-speaker voice colour. Two speakers with different timbres have
+	 * measurably different spectral envelopes, so an acoustic diarizer can tell
+	 * them apart from the audio alone. Omit for the default (shared) voice — the
+	 * VAD/wake-word smoke fixtures don't care who is speaking.
+	 */
+	timbre?: SpeakerTimbre;
+}
+
+/** A speaker's voice colour: fundamental frequency + vocal-tract formants. */
+export interface SpeakerTimbre {
+	/** Base fundamental frequency (Hz) — speaker pitch. */
+	f0Hz: number;
+	/** Three `[centerHz, bandwidthHz]` formants — the vocal-tract resonances. */
+	formants: ReadonlyArray<readonly [number, number]>;
 }
 
 export interface SpeechFixture {
@@ -85,6 +100,57 @@ const DEFAULT_FORMANTS: ReadonlyArray<readonly [number, number]> = [
 	[2600, 120],
 ];
 
+/** The shared (speaker-agnostic) voice used when no `timbre` is supplied. */
+export const DEFAULT_SPEAKER_TIMBRE: SpeakerTimbre = {
+	f0Hz: 110,
+	formants: DEFAULT_FORMANTS,
+};
+
+/**
+ * Deterministic, distinct voice colour for participant `index` of `count`
+ * speakers in a scenario. The speakers are spread EVENLY across a wide
+ * vocal-tract-length (formant-scaling) and pitch range, so every pair in a
+ * scenario is acoustically far apart — a blind acoustic diarizer can split them
+ * from the audio alone — while one participant always gets one timbre, so the
+ * same speaker clusters together. Spreading by position (not by a label hash)
+ * guarantees the separation; two labels could otherwise hash to near-identical
+ * voices and merge.
+ */
+export function speakerTimbreForIndex(
+	index: number,
+	count: number,
+): SpeakerTimbre {
+	const frac = count <= 1 ? 0.5 : index / (count - 1); // 0..1
+	// Vocal-tract scaling 0.72..1.32 (shorter tract → higher formants).
+	const formantScale = 0.72 + frac * 0.6;
+	// Alternate the second formant up/down so even adjacent slots differ in
+	// formant PATTERN (F2 is the most speaker-discriminative resonance), not just
+	// a global shift.
+	const f2Bias = index % 2 === 0 ? 1.06 : 0.94;
+	const formants = DEFAULT_FORMANTS.map(([fc, bw], i) => {
+		const bias = i === 1 ? f2Bias : 1;
+		return [fc * formantScale * bias, bw] as const;
+	});
+	// Pitch 98..202 Hz.
+	const f0Hz = 98 + frac * 104;
+	return { f0Hz, formants };
+}
+
+/**
+ * The agent's own synthetic TTS voice — a fixed timbre, deliberately placed
+ * outside the speaker-seed range so it is acoustically distinct from every
+ * scenario participant. The corpus synthesizes agent-echo turns with this voice,
+ * and the acoustic self-voice gate enrolls it as the agent's imprint.
+ */
+export const AGENT_VOICE_TIMBRE: SpeakerTimbre = {
+	f0Hz: 250,
+	formants: [
+		[1100, 90],
+		[2400, 110],
+		[3800, 150],
+	],
+};
+
 /** Build a `silence + synthesized speech + silence` PCM buffer. */
 export function makeSpeechWithSilenceFixture(
 	opts: SpeechFixtureOptions = {},
@@ -100,12 +166,16 @@ export function makeSpeechWithSilenceFixture(
 	const speechEndSample = Math.floor((leadSec + speechSec) * sampleRate);
 
 	const rng = mulberry32(opts.seed ?? 0xe11a);
-	const bank = new FormantBank(sampleRate, DEFAULT_FORMANTS);
+	const timbre = opts.timbre ?? DEFAULT_SPEAKER_TIMBRE;
+	const bank = new FormantBank(sampleRate, timbre.formants);
 	let phase = 0;
 	for (let i = speechStartSample; i < speechEndSample; i++) {
 		const tInSpeech = (i - speechStartSample) / sampleRate;
+		// Syllable-rate vibrato proportional to the speaker's base pitch (the
+		// original shared voice swung 30 Hz around 110 Hz ≈ ±27%).
 		const f0 =
-			110 + 30 * Math.sin(2 * Math.PI * 5 * tInSpeech) + (rng() - 0.5) * 4;
+			timbre.f0Hz * (1 + 0.27 * Math.sin(2 * Math.PI * 5 * tInSpeech)) +
+			(rng() - 0.5) * 4;
 		phase += f0 / sampleRate;
 		let excitation = 0;
 		if (phase >= 1) {

package/src/services/voice/__tests__/eliza1-eot-scorer.test.ts

@@ -19,11 +19,11 @@ import {
 	type Eliza1EotScorerOptions,
 } from "../eot-classifier";
 
-const IM_END_ID = 199;
+const END_OF_TURN_ID = 199;
 
 /**
  * Minimal fake llama model the scorer can drive. The `score()` parameter
- * is the probability we want the fake model to return for `<|im_end|>`
+ * is the probability we want the fake model to return for `<end_of_turn>`
  * on the next token. Token IDs are derived from char codes so two calls
  * with different prompts produce different token sequences.
  */
@@ -36,7 +36,7 @@ interface FakeModelHandle {
 }
 
 function buildFakeModel(opts: {
-	imEndProbability: () => number;
+	endOfTurnProbability: () => number;
 	disposeSpy?: () => void;
 }): FakeModelHandle {
 	const tokenizeCalls: string[] = [];
@@ -55,11 +55,11 @@ function buildFakeModel(opts: {
 					i === input.length - 1
 						? {
 								next: {
-									token: IM_END_ID,
-									confidence: opts.imEndProbability(),
+									token: END_OF_TURN_ID,
+									confidence: opts.endOfTurnProbability(),
 									probabilities: new Map<number, number>([
-										[IM_END_ID, opts.imEndProbability()],
-										[42, 1 - opts.imEndProbability()],
+										[END_OF_TURN_ID, opts.endOfTurnProbability()],
+										[42, 1 - opts.endOfTurnProbability()],
 									]),
 								},
 							}
@@ -79,8 +79,8 @@ function buildFakeModel(opts: {
 	const model: LlamaModelLike = {
 		tokenize(text: string, specialTokens?: boolean) {
 			tokenizeCalls.push(text);
-			if (text === "<|im_end|>")
-				return specialTokens ? [IM_END_ID] : [101, 102];
+			if (text === "<end_of_turn>")
+				return specialTokens ? [END_OF_TURN_ID] : [101, 102];
 			return Array.from(text).map((c) => c.charCodeAt(0));
 		},
 		async createContext(args) {
@@ -99,33 +99,33 @@ function buildFakeModel(opts: {
 }
 
 describe("formatEotPrompt", () => {
-	it("renders a single-user Qwen turn with the im_end stripped", () => {
+	it("renders a single-user Gemma turn with the end_of_turn stripped", () => {
 		const prompt = formatEotPrompt("hello world");
-		expect(prompt).toBe("<|im_start|>user\nhello world");
-		expect(prompt).not.toContain("<|im_end|>");
+		expect(prompt).toBe("<start_of_turn>user\nhello world");
+		expect(prompt).not.toContain("<end_of_turn>");
 	});
 
 	it("trims whitespace so leading/trailing space does not affect scoring", () => {
-		expect(formatEotPrompt("  hi  ")).toBe("<|im_start|>user\nhi");
+		expect(formatEotPrompt("  hi  ")).toBe("<start_of_turn>user\nhi");
 	});
 });
 
 describe("Eliza1EotScorer", () => {
-	it("returns P(<|im_end|>) reported by the model on the last token", async () => {
-		const fake = buildFakeModel({ imEndProbability: () => 0.83 });
+	it("returns P(<end_of_turn>) reported by the model on the last token", async () => {
+		const fake = buildFakeModel({ endOfTurnProbability: () => 0.83 });
 		const scorer = new Eliza1EotScorer({ model: fake.model });
 		const result = await scorer.score("hello world.");
 		expect(result.probability).toBeCloseTo(0.83, 5);
 		expect(result.promptTokens).toBeGreaterThan(0);
-		// `<|im_end|>` resolution happens once during initialization.
-		expect(fake.tokenizeCalls[0]).toBe("<|im_end|>");
+		// `<end_of_turn>` resolution happens once during initialization.
+		expect(fake.tokenizeCalls[0]).toBe("<end_of_turn>");
 	});
 
 	it("falls back to 0.5 when the probabilities map is missing", async () => {
 		const fake = {
 			model: {
 				tokenize(text: string) {
-					return text === "<|im_end|>" ? [IM_END_ID] : [1, 2, 3];
+					return text === "<end_of_turn>" ? [END_OF_TURN_ID] : [1, 2, 3];
 				},
 				async createContext() {
 					return {
@@ -148,14 +148,14 @@ describe("Eliza1EotScorer", () => {
 	});
 
 	it("uses the model score for empty transcript input", async () => {
-		const fake = buildFakeModel({ imEndProbability: () => 0.9 });
+		const fake = buildFakeModel({ endOfTurnProbability: () => 0.9 });
 		const scorer = new Eliza1EotScorer({ model: fake.model });
 		const result = await scorer.score("   ");
 		expect(result.probability).toBe(0.9);
 	});
 
 	it("attaches a LoRA adapter to the context when loraPath is set", async () => {
-		const fake = buildFakeModel({ imEndProbability: () => 0.5 });
+		const fake = buildFakeModel({ endOfTurnProbability: () => 0.5 });
 		const scorer = new Eliza1EotScorer({
 			model: fake.model,
 			loraPath: "/tmp/fake-eot.gguf",
@@ -173,7 +173,7 @@ describe("Eliza1EotScorer", () => {
 	});
 
 	it("truncates the prompt to maxHistoryTokens", async () => {
-		const fake = buildFakeModel({ imEndProbability: () => 0.5 });
+		const fake = buildFakeModel({ endOfTurnProbability: () => 0.5 });
 		const scorer = new Eliza1EotScorer({
 			model: fake.model,
 			maxHistoryTokens: 5,
@@ -184,12 +184,12 @@ describe("Eliza1EotScorer", () => {
 		expect(fake.controlledEvaluateCalls[0]).toHaveLength(5);
 	});
 
-	it("throws a descriptive error when the tokenizer does not resolve im_end to a single id", async () => {
+	it("throws a descriptive error when the tokenizer does not resolve end_of_turn to a single id", async () => {
 		const fake: LlamaModelLike = {
 			tokenize(text: string) {
-				// Simulate a non-Qwen model where <|im_end|> tokenizes to plain
+				// Simulate a non-Gemma model where <end_of_turn> tokenizes to plain
 				// text (multiple ids).
-				if (text === "<|im_end|>") return [10, 11, 12];
+				if (text === "<end_of_turn>") return [10, 11, 12];
 				return [1, 2, 3];
 			},
 			async createContext() {
@@ -197,13 +197,13 @@ describe("Eliza1EotScorer", () => {
 			},
 		};
 		const scorer = new Eliza1EotScorer({ model: fake });
-		await expect(scorer.score("x")).rejects.toThrow(/<\|im_end\|>/);
+		await expect(scorer.score("x")).rejects.toThrow(/<end_of_turn>/);
 	});
 
 	it("disposes the context on dispose()", async () => {
 		const disposeSpy = vi.fn();
 		const fake = buildFakeModel({
-			imEndProbability: () => 0.5,
+			endOfTurnProbability: () => 0.5,
 			disposeSpy,
 		});
 		const scorer = new Eliza1EotScorer({ model: fake.model });
@@ -217,7 +217,7 @@ describe("Eliza1EotScorer", () => {
 		let maxInflight = 0;
 		const fake: LlamaModelLike = {
 			tokenize(text: string) {
-				if (text === "<|im_end|>") return [IM_END_ID];
+				if (text === "<end_of_turn>") return [END_OF_TURN_ID];
 				return [1, 2, 3];
 			},
 			async createContext() {
@@ -234,7 +234,7 @@ describe("Eliza1EotScorer", () => {
 									? {
 											next: {
 												probabilities: new Map<number, number>([
-													[IM_END_ID, 0.6],
+													[END_OF_TURN_ID, 0.6],
 												]),
 											},
 										}
@@ -258,7 +258,7 @@ describe("Eliza1EotScorer", () => {
 
 describe("Eliza1EotClassifier", () => {
 	function buildOpts(probability: number): Eliza1EotScorerOptions {
-		const fake = buildFakeModel({ imEndProbability: () => probability });
+		const fake = buildFakeModel({ endOfTurnProbability: () => probability });
 		return { model: fake.model };
 	}