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

package/src/services/voice/transcript-store.test.ts

@@ -0,0 +1,153 @@
+import type { Memory, UUID } from "@elizaos/core";
+import type { Transcript } from "@elizaos/shared/transcripts";
+import { describe, expect, it } from "vitest";
+import {
+	TRANSCRIPTS_TABLE,
+	TranscriptStore,
+	type TranscriptStoreRuntime,
+} from "./transcript-store";
+
+function makeTranscript(over: Partial<Transcript> = {}): Transcript {
+	return {
+		id: "00000000-0000-0000-0000-000000000001",
+		title: "Standup",
+		createdAt: 1000,
+		durationMs: 2000,
+		audioUrl: "/api/media/x.wav",
+		source: "voice-session",
+		scope: "owner-private",
+		status: "ready",
+		speakerCount: 1,
+		segments: [
+			{
+				id: "s1",
+				speakerLabel: "Alice",
+				startMs: 0,
+				endMs: 2000,
+				text: "hello world",
+				words: [{ text: "hello", startMs: 0, endMs: 1000 }],
+			},
+		],
+		...over,
+	};
+}
+
+/** In-memory fake runtime backing the memory partition. */
+function fakeRuntime(): TranscriptStoreRuntime & { rows: Map<string, Memory> } {
+	const rows = new Map<string, Memory>();
+	const tables = new Map<string, string>();
+	return {
+		rows,
+		agentId: "agent-1" as UUID,
+		async createMemory(memory, tableName) {
+			const id = memory.id as UUID;
+			rows.set(id, memory);
+			tables.set(id, tableName);
+			return id;
+		},
+		async getMemories({ tableName, roomId, orderDirection }) {
+			let out = [...rows.values()].filter(
+				(m) => tables.get(m.id as string) === tableName,
+			);
+			if (roomId) out = out.filter((m) => m.roomId === roomId);
+			out.sort((a, b) =>
+				orderDirection === "asc"
+					? (a.createdAt ?? 0) - (b.createdAt ?? 0)
+					: (b.createdAt ?? 0) - (a.createdAt ?? 0),
+			);
+			return out;
+		},
+		async getMemoryById(id) {
+			return rows.get(id) ?? null;
+		},
+		async deleteMemory(id) {
+			rows.delete(id);
+		},
+	};
+}
+
+const ROOM = "11111111-1111-1111-1111-111111111111" as UUID;
+const ENTITY = "22222222-2222-2222-2222-222222222222" as UUID;
+
+describe("TranscriptStore", () => {
+	it("persists into the transcripts partition and round-trips the full record", async () => {
+		const rt = fakeRuntime();
+		const store = new TranscriptStore(rt);
+		const t = makeTranscript();
+		await store.create({ roomId: ROOM, entityId: ENTITY, transcript: t });
+
+		// Stored as one memory row with the full transcript in content.transcript.
+		const row = rt.rows.get(t.id) as Memory;
+		expect(row.roomId).toBe(ROOM);
+		expect(row.entityId).toBe(ENTITY);
+		expect(row.metadata?.type).toBe("custom");
+		expect(row.metadata?.source).toBe("transcript");
+		// The full record is stored as a JSON blob in content.transcript.
+		expect(typeof (row.content as { transcript: string }).transcript).toBe(
+			"string",
+		);
+		// A text preview body is present for generic memory consumers.
+		expect(row.content.text).toBe("hello world");
+
+		// store.get parses the blob back into the exact record.
+		const got = await store.get(t.id as UUID);
+		expect(got).toEqual(t);
+	});
+
+	it("lists newest-first summaries scoped to a room", async () => {
+		const rt = fakeRuntime();
+		const store = new TranscriptStore(rt);
+		await store.create({
+			roomId: ROOM,
+			entityId: ENTITY,
+			transcript: makeTranscript({
+				id: "00000000-0000-0000-0000-0000000000aa",
+				title: "Older",
+				createdAt: 1000,
+			}),
+		});
+		await store.create({
+			roomId: ROOM,
+			entityId: ENTITY,
+			transcript: makeTranscript({
+				id: "00000000-0000-0000-0000-0000000000bb",
+				title: "Newer",
+				createdAt: 2000,
+			}),
+		});
+		// A transcript in a different room must not appear.
+		await store.create({
+			roomId: "33333333-3333-3333-3333-333333333333" as UUID,
+			entityId: ENTITY,
+			transcript: makeTranscript({
+				id: "00000000-0000-0000-0000-0000000000cc",
+				title: "Other room",
+				createdAt: 3000,
+			}),
+		});
+
+		const list = await store.list(ROOM);
+		expect(list.map((s) => s.title)).toEqual(["Newer", "Older"]);
+		expect(list[0]).toMatchObject({
+			durationMs: 2000,
+			hasAudio: true,
+			status: "ready",
+		});
+	});
+
+	it("returns null for a missing id and deletes a record", async () => {
+		const rt = fakeRuntime();
+		const store = new TranscriptStore(rt);
+		expect(
+			await store.get("deadbeef-0000-0000-0000-000000000000" as UUID),
+		).toBeNull();
+		const t = makeTranscript();
+		await store.create({ roomId: ROOM, entityId: ENTITY, transcript: t });
+		await store.delete(t.id as UUID);
+		expect(await store.get(t.id as UUID)).toBeNull();
+	});
+
+	it("exposes the partition name", () => {
+		expect(TRANSCRIPTS_TABLE).toBe("transcripts");
+	});
+});

package/src/services/voice/transcript-store.ts

@@ -0,0 +1,132 @@
+/**
+ * Transcript store (#8789 transcripts) — persistence for the rich transcript
+ * record (audio URL + word-timed diarized segments).
+ *
+ * Reuses the runtime's proven `memories` partition mechanism (exactly how the
+ * documents store works) rather than a new table/migration: each transcript is
+ * one memory row in the `"transcripts"` partition, with the full {@link Transcript}
+ * in `content.transcript`. The player loads a whole record by id and the list
+ * reads recent rows — no querying INSIDE segments is needed, because search is
+ * served by the knowledge mirror (see `transcript-knowledge.ts`). A custom
+ * `metadata.type` keeps it clear of the document/fragment CHECK constraints.
+ */
+
+import type { Memory, MemoryMetadata, UUID } from "@elizaos/core";
+import type {
+	Transcript,
+	TranscriptSummary,
+} from "@elizaos/shared/transcripts";
+import {
+	summarizeTranscript,
+	transcriptPreview,
+} from "@elizaos/shared/transcripts";
+
+/** The `type` column partition transcripts live in (sibling to "messages"). */
+export const TRANSCRIPTS_TABLE = "transcripts";
+/** `metadata.type` marker — NOT "document"/"fragment", so no CHECK fires. */
+export const TRANSCRIPT_METADATA_TYPE = "transcript";
+
+/** The subset of `IAgentRuntime` the store needs (real runtime satisfies it). */
+export interface TranscriptStoreRuntime {
+	agentId: UUID;
+	createMemory(
+		memory: Memory,
+		tableName: string,
+		unique?: boolean,
+	): Promise<UUID>;
+	getMemories(params: {
+		tableName: string;
+		roomId?: UUID;
+		count?: number;
+		orderBy?: "createdAt";
+		orderDirection?: "asc" | "desc";
+	}): Promise<Memory[]>;
+	getMemoryById(id: UUID): Promise<Memory | null>;
+	deleteMemory(id: UUID): Promise<void>;
+}
+
+export interface CreateTranscriptInput {
+	roomId: UUID;
+	/** The owner/speaker entity the recording is attributed to. */
+	entityId: UUID;
+	/** The fully-built transcript record (audio + segments + words). */
+	transcript: Transcript;
+}
+
+/** Pull the stored {@link Transcript} back out of a memory row (parses the
+ *  JSON blob; a corrupt/legacy row yields null and is skipped by the list). */
+function rowToTranscript(row: Memory): Transcript | null {
+	const raw = (row.content as { transcript?: unknown }).transcript;
+	if (typeof raw !== "string") return null;
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return parsed && typeof parsed === "object" ? (parsed as Transcript) : null;
+	} catch {
+		return null;
+	}
+}
+
+/** CRUD for transcript records over the runtime memory partition. */
+export class TranscriptStore {
+	constructor(private readonly runtime: TranscriptStoreRuntime) {}
+
+	/** Persist a transcript record; returns it unchanged. */
+	async create(input: CreateTranscriptInput): Promise<Transcript> {
+		const { roomId, entityId, transcript } = input;
+		const metadata: MemoryMetadata = {
+			type: "custom",
+			source: TRANSCRIPT_METADATA_TYPE,
+			timestamp: transcript.createdAt,
+			transcriptId: transcript.id,
+			durationMs: transcript.durationMs,
+			speakerCount: transcript.speakerCount,
+			status: transcript.status,
+		};
+		const memory: Memory = {
+			id: transcript.id as UUID,
+			entityId,
+			roomId,
+			agentId: this.runtime.agentId,
+			createdAt: transcript.createdAt,
+			content: {
+				// A text body so generic memory consumers see something useful.
+				text: transcriptPreview(transcript.segments),
+				// The full record is JSON-serialized into the content blob — Content's
+				// value type is strict JSON, so a typed interface isn't structurally
+				// assignable; `rowToTranscript` parses it back.
+				transcript: JSON.stringify(transcript),
+			},
+			metadata,
+		};
+		await this.runtime.createMemory(memory, TRANSCRIPTS_TABLE);
+		return transcript;
+	}
+
+	/** List recent transcripts (newest first) as compact summaries. */
+	async list(roomId?: UUID, limit = 100): Promise<TranscriptSummary[]> {
+		const rows = await this.runtime.getMemories({
+			tableName: TRANSCRIPTS_TABLE,
+			roomId,
+			count: limit,
+			orderBy: "createdAt",
+			orderDirection: "desc",
+		});
+		const summaries: TranscriptSummary[] = [];
+		for (const row of rows) {
+			const t = rowToTranscript(row);
+			if (t) summaries.push(summarizeTranscript(t));
+		}
+		return summaries;
+	}
+
+	/** Load one full transcript record by id. */
+	async get(id: UUID): Promise<Transcript | null> {
+		const row = await this.runtime.getMemoryById(id);
+		return row ? rowToTranscript(row) : null;
+	}
+
+	/** Delete a transcript record (the knowledge mirror is removed separately). */
+	async delete(id: UUID): Promise<void> {
+		await this.runtime.deleteMemory(id);
+	}
+}

package/src/services/voice/turn-controller.d.ts

@@ -0,0 +1,183 @@
+/**
+ * Voice turn controller — the turn-taking layer above `VoiceScheduler`.
+ *
+ * Sits between W1's `VadEvent` stream + W2's `StreamingTranscriber` events
+ * and the generation path (the runtime message handler / the local engine's
+ * `generate`, which routes through `voiceStreamingArgs` → `VoiceScheduler` →
+ * phrase chunker → TTS). Implements the brief's items A4 / A5 / A6:
+ *
+ *   - `speech-start`           → fire `prewarm(roomId)` immediately (the
+ *                                response-handler stable prefix / MTP
+ *                                slot KV-prefill) — before STT finishes.
+ *   - `speech-pause(ms > thr)` → kick a SPECULATIVE response off W2's
+ *                                current partial transcript. The generate
+ *                                call gets an `AbortSignal`; the in-flight
+ *                                generation is stashed.
+ *   - `speech-active` / a new `speech-start` / VAD re-trigger
+ *                              → ABORT the speculative generation (the abort
+ *                                propagates into `dispatcher.generate`).
+ *   - `speech-end` (no new speech)
+ *                              → finalize: flush the transcriber for the
+ *                                final transcript; if the speculative result
+ *                                is still valid against it, PROMOTE it; else
+ *                                discard and run the real turn on the
+ *                                finalized transcript.
+ *
+ * Barge-in: while the agent is speaking the controller flips
+ * `scheduler.bargeIn.setAgentSpeaking(true)` (and binds the VAD into the
+ * barge-in controller). A provisional `pause-tts` pauses TTS in the
+ * scheduler; a `blip` → `resume-tts`; ASR-confirmed words → `hard-stop` →
+ * the scheduler drains the ring buffer + flushes the chunker, and the
+ * controller aborts the in-flight turn (the same `AbortSignal` the engine
+ * threads into `dispatcher.generate`). The transcriber's `words` event is
+ * wired into `bargeIn.onWordsDetected({wordCount})` so a blip alone only
+ * pauses, but real recognized words hard-stop.
+ *
+ * No fallback sludge: `prewarm` failures surface via `onError`; a speculative
+ * abort is a real `AbortSignal.abort()`, never a swallowed flag.
+ */
+import { type EotClassifier, type VoiceTurnSignal } from "./eot-classifier";
+import type { VoiceScheduler } from "./scheduler";
+import type { StreamingTranscriber, VadEventSource, VoiceInputSource, VoiceSegment, VoiceSpeaker, VoiceTurnMetadata } from "./types";
+/** Outcome of one generation pass (speculative or final). */
+export interface VoiceTurnOutcome {
+    /** The transcript the generation ran against (so the controller can
+     *  decide whether a speculative result is still valid). */
+    transcript: string;
+    /** Voice attribution metadata for the transcript that produced this outcome. */
+    source?: VoiceInputSource;
+    speaker?: VoiceSpeaker;
+    segments?: VoiceSegment[];
+    turn?: VoiceTurnMetadata;
+    /** Final reply text the model produced (already streamed into TTS by the
+     *  generate callee). May be empty for an IGNORE turn. */
+    replyText: string;
+}
+export interface VoiceGenerateRequest {
+    /** Best transcript available at the time the request is issued. */
+    transcript: string;
+    /** Optional source/speaker metadata for attribution-only storage. */
+    source?: VoiceInputSource;
+    speaker?: VoiceSpeaker;
+    segments?: VoiceSegment[];
+    turn?: VoiceTurnMetadata;
+    /** True for the finalized turn (post `speech-end` + `flush()`), false for
+     *  a speculative pass off a partial. */
+    final: boolean;
+    /** Aborted when speech resumes (speculative) or on a hard-stop barge-in. */
+    signal: AbortSignal;
+    /**
+     * Semantic turn-taking signal available at request issue time. Response
+     * handlers can deterministically suppress/accept without waiting for another
+     * model token when this says the next speaker is not the agent.
+     */
+    turnSignal?: VoiceTurnSignal;
+}
+export interface VoiceTurnControllerDeps {
+    /** W1: the authoritative VAD event stream (a `VadDetector` is structurally one of these). */
+    vad: VadEventSource;
+    /** W2: the live streaming transcriber. The controller subscribes to its
+     *  events and calls `flush()` on `speech-end`. */
+    transcriber: StreamingTranscriber;
+    /** W9: the voice scheduler — used for the barge-in controller + agent-speaking flag. */
+    scheduler: VoiceScheduler;
+    /**
+     * KV-prefill / response-handler-prefix prewarm. Called on `speech-start`.
+     * Fire-and-forget; a rejection is surfaced via `onError`, not swallowed.
+     * (In the engine this wraps `engine.prewarmConversation(roomId, ...)` /
+     * `runtime.prewarmResponseHandler(roomId)`.)
+     */
+    prewarm?: (roomId: string) => void | Promise<void>;
+    /** Optional cached first-audio filler played immediately on speech-start. */
+    playFirstAudioFiller?: () => string | null;
+    /**
+     * Semantic turn detector layered with VAD/STT. It runs continuously on
+     * partial transcripts so `speech-pause` can decide whether to speculate or
+     * wait for the user to continue.
+     */
+    turnDetector?: EotClassifier;
+    /**
+     * Run a generation pass. The callee builds the message, calls the runtime
+     * message handler / `useModel`, and streams `replyText` into TTS via the
+     * scheduler. Must honour `request.signal` (abort = stop the LLM/drafter at
+     * the next kernel boundary). Resolves with the produced reply + the
+     * transcript it ran against. Rejecting with the request's `AbortError` is
+     * fine — the controller treats that as "aborted".
+     */
+    generate: (request: VoiceGenerateRequest) => Promise<VoiceTurnOutcome>;
+}
+export interface VoiceTurnControllerConfig {
+    /** Conversation / room id passed to `prewarm` and (implicitly) `generate`. */
+    roomId: string;
+    /**
+     * Minimum `speech-pause` duration before a speculative response is kicked.
+     * Default 300 ms — long enough that mid-sentence breath pauses don't
+     * trigger one, short enough to win latency on a real end-of-utterance.
+     */
+    speculatePauseMs?: number;
+}
+export interface VoiceTurnControllerEvents {
+    /** A speculative generation was started off a partial transcript. */
+    onSpeculativeStart?(transcript: string): void;
+    /** The in-flight speculative generation was aborted (speech resumed). */
+    onSpeculativeAbort?(): void;
+    /** The speculative result was promoted as the turn's answer (it matched the final transcript). */
+    onSpeculativePromoted?(outcome: VoiceTurnOutcome): void;
+    /** A turn finished (promoted speculative OR a fresh final run). */
+    onTurnComplete?(outcome: VoiceTurnOutcome): void;
+    /** `prewarm` rejected, or a `generate` pass rejected with a non-abort error. */
+    onError?(error: Error): void;
+    /** A VAD pause/end was suppressed because semantic turn-taking says user continues. */
+    onTurnSuppressed?(transcript: string, signal: VoiceTurnSignal): void;
+}
+export declare class VoiceTurnController {
+    private readonly deps;
+    private readonly events;
+    private readonly roomId;
+    private readonly speculatePauseMs;
+    private readonly bargeIn;
+    private speculative;
+    /** A finalize() in progress (awaiting `transcriber.flush()` + generate). */
+    private finalizing;
+    private latestPartial;
+    private latestTurnSignal;
+    private turnSignalSequence;
+    private started;
+    private vadUnsub;
+    private transcriberUnsub;
+    private bargeSignalUnsub;
+    private activeFinalController;
+    /** True once `speech-end` ran and finalize is pending/done for this segment. */
+    private segmentEnded;
+    private latestUpdate;
+    constructor(deps: VoiceTurnControllerDeps, config: VoiceTurnControllerConfig, events?: VoiceTurnControllerEvents);
+    /** Subscribe to the VAD + transcriber streams and start turn-taking. Idempotent. */
+    start(): void;
+    /** Detach from the streams and abort any in-flight speculative generation. */
+    stop(): void;
+    private onVadEvent;
+    private onTranscriberEvent;
+    /**
+     * C2 — public idle prewarm entry point. Callers (e.g. the UI when a
+     * conversation opens) invoke this to materialize the KV cache for the
+     * response-handler stable prefix BEFORE the user starts speaking, so the
+     * first speech-start has nothing left to do. Fire-and-forget: the
+     * returned promise is `void` because we don't want callers blocking on
+     * prewarm; failures surface via `onError` exactly like the speech-start
+     * path. Idempotent — repeated calls just re-prewarm.
+     */
+    prewarmOnIdle(): void;
+    private firePrewarm;
+    private playFirstAudioFiller;
+    private maybeStartSpeculative;
+    private startSpeculativeAfterTurnSignal;
+    private startSpeculative;
+    private abortSpeculative;
+    private beginFinalize;
+    private finalize;
+    private runGenerate;
+    private queueTurnSignalRefresh;
+    private ensureTurnSignal;
+    private computeTurnSignal;
+}
+//# sourceMappingURL=turn-controller.d.ts.map

package/src/services/voice/turn-controller.d.ts.map

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