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

package/src/routes/transcripts-routes.test.ts

@@ -0,0 +1,195 @@
+import type { Memory, RouteHandlerContext, UUID } from "@elizaos/core";
+import type { TranscriptSegment } from "@elizaos/shared/transcripts";
+import { describe, expect, it } from "vitest";
+import {
+	buildTranscriptFromRequest,
+	type CreateTranscriptRequest,
+	transcriptsRoutes,
+} from "./transcripts-routes";
+
+const WORLD = "00000000-0000-0000-0000-0000000000ww" as UUID;
+const ROOM = "11111111-1111-1111-1111-111111111111" as UUID;
+const ENTITY = "22222222-2222-2222-2222-222222222222" as UUID;
+
+const segments: TranscriptSegment[] = [
+	{
+		id: "s1",
+		speakerLabel: "Alice",
+		startMs: 0,
+		endMs: 1000,
+		text: "hi there",
+		words: [],
+	},
+	{
+		id: "s2",
+		speakerLabel: "Bob",
+		startMs: 1200,
+		endMs: 2500,
+		text: "hello",
+		words: [],
+	},
+];
+
+function fakeRuntime(): { rows: Map<string, Memory>; runtime: unknown } {
+	const rows = new Map<string, Memory>();
+	const runtime = {
+		agentId: "agent-1" as UUID,
+		createMemory: async (m: Memory) => {
+			rows.set(m.id as string, m);
+			return m.id as UUID;
+		},
+		getMemories: async () => [...rows.values()],
+		getMemoryById: async (id: UUID) => rows.get(id) ?? null,
+		updateMemory: async (m: Partial<Memory> & { id: UUID }) => {
+			const existing = rows.get(m.id);
+			if (!existing) return false;
+			rows.set(m.id, { ...existing, ...m });
+			return true;
+		},
+		deleteMemory: async (id: UUID) => {
+			rows.delete(id);
+		},
+		getService: () => null, // no documents service in this test
+	};
+	return { rows, runtime };
+}
+
+function ctx(over: Partial<RouteHandlerContext>): RouteHandlerContext {
+	return {
+		params: {},
+		query: {},
+		body: undefined,
+		headers: {},
+		method: "GET",
+		path: "/api/transcripts",
+		inProcess: true,
+		...over,
+	} as RouteHandlerContext;
+}
+
+function handlerFor(type: string, path: string) {
+	const r = transcriptsRoutes.find((x) => x.type === type && x.path === path);
+	if (!r?.routeHandler) throw new Error(`no route ${type} ${path}`);
+	return r.routeHandler;
+}
+
+describe("buildTranscriptFromRequest", () => {
+	it("derives duration + speaker count + defaults", () => {
+		const body: CreateTranscriptRequest = {
+			worldId: WORLD,
+			roomId: ROOM,
+			entityId: ENTITY,
+			segments,
+			createdAt: 1000,
+		};
+		const t = buildTranscriptFromRequest(body, "id-1", 9000);
+		expect(t.durationMs).toBe(2500);
+		expect(t.speakerCount).toBe(2);
+		expect(t.scope).toBe("owner-private");
+		expect(t.source).toBe("voice-session");
+		expect(t.status).toBe("ready");
+		expect(t.createdAt).toBe(1000);
+		expect(t.endedAt).toBe(9000);
+		expect(t.title).toContain("Recording");
+	});
+});
+
+describe("transcripts routes", () => {
+	it("POST creates, GET reads it back, GET list summarizes, DELETE removes", async () => {
+		const { runtime } = fakeRuntime();
+		// No world/room/entity ids — the route derives them from the agent context.
+		const body: CreateTranscriptRequest = {
+			title: "Standup",
+			segments,
+		};
+		const created = await handlerFor(
+			"POST",
+			"/api/transcripts",
+		)(ctx({ runtime: runtime as never, body }));
+		expect(created.status).toBe(201);
+		const id = (created.body as { transcript: { id: string } }).transcript.id;
+		expect(typeof id).toBe("string");
+
+		const got = await handlerFor(
+			"GET",
+			"/api/transcripts/:id",
+		)(ctx({ runtime: runtime as never, params: { id } }));
+		expect(got.status).toBe(200);
+		expect(
+			(got.body as { transcript: { title: string } }).transcript.title,
+		).toBe("Standup");
+
+		const list = await handlerFor(
+			"GET",
+			"/api/transcripts",
+		)(ctx({ runtime: runtime as never }));
+		expect((list.body as { transcripts: unknown[] }).transcripts).toHaveLength(
+			1,
+		);
+
+		const del = await handlerFor(
+			"DELETE",
+			"/api/transcripts/:id",
+		)(ctx({ runtime: runtime as never, params: { id } }));
+		expect(del.status).toBe(200);
+		const after = await handlerFor(
+			"GET",
+			"/api/transcripts/:id",
+		)(ctx({ runtime: runtime as never, params: { id } }));
+		expect(after.status).toBe(404);
+	});
+
+	it("POST rejects a body with no segments", async () => {
+		const { runtime } = fakeRuntime();
+		const res = await handlerFor(
+			"POST",
+			"/api/transcripts",
+		)(ctx({ runtime: runtime as never, body: { segments: [] } }));
+		expect(res.status).toBe(400);
+	});
+
+	it("PUT edits an existing transcript and 404s on a missing one", async () => {
+		const { runtime } = fakeRuntime();
+		const created = await handlerFor(
+			"POST",
+			"/api/transcripts",
+		)(ctx({ runtime: runtime as never, body: { title: "Raw", segments } }));
+		const id = (created.body as { transcript: { id: string } }).transcript.id;
+
+		const put = await handlerFor(
+			"PUT",
+			"/api/transcripts/:id",
+		)(
+			ctx({
+				runtime: runtime as never,
+				params: { id },
+				body: { title: "Fixed title" },
+			}),
+		);
+		expect(put.status).toBe(200);
+		expect(
+			(put.body as { transcript: { title: string } }).transcript.title,
+		).toBe("Fixed title");
+
+		const missing = await handlerFor(
+			"PUT",
+			"/api/transcripts/:id",
+		)(
+			ctx({
+				runtime: runtime as never,
+				params: { id: "00000000-0000-0000-0000-0000000000ff" },
+				body: { title: "x" },
+			}),
+		);
+		expect(missing.status).toBe(404);
+	});
+
+	it("PUT rejects a body with neither title nor segments", async () => {
+		const { runtime } = fakeRuntime();
+		const res = await handlerFor(
+			"PUT",
+			"/api/transcripts/:id",
+		)(ctx({ runtime: runtime as never, params: { id: "x" }, body: {} }));
+		expect(res.status).toBe(400);
+	});
+});

package/src/routes/transcripts-routes.ts

@@ -0,0 +1,191 @@
+/**
+ * Transcript HTTP routes (#8789) — `/api/transcripts*`, served as rawPath plugin
+ * routes (on `runtime.routes`, dispatched by both the upstream agent server and
+ * app-core) so the Transcripts view + the recording pipeline have a backend.
+ * Audio is served by the existing content-addressed media store via each
+ * record's `audioUrl`, so no separate audio route is needed.
+ *
+ * Private routes: the host dispatcher answers 401 for unauthenticated callers.
+ */
+
+import type {
+	Route,
+	RouteHandlerContext,
+	RouteHandlerResult,
+	UUID,
+} from "@elizaos/core";
+import {
+	type Transcript,
+	type TranscriptScope,
+	type TranscriptSegment,
+	type TranscriptSource,
+	transcriptDurationMs,
+	transcriptSpeakerCount,
+} from "@elizaos/shared/transcripts";
+import {
+	TranscriptService,
+	type TranscriptServiceRuntime,
+} from "../services/voice/transcript-service.js";
+import { persistTranscriptAudioWav } from "./transcript-audio-store.js";
+
+function service(ctx: RouteHandlerContext): TranscriptService {
+	return new TranscriptService(ctx.runtime as TranscriptServiceRuntime);
+}
+
+/** The body a recording session POSTs to create a transcript record. */
+export interface CreateTranscriptRequest {
+	/** Optional — the route derives these from the agent context when absent (the
+	 *  shell client doesn't carry world/room/entity ids). */
+	worldId?: UUID;
+	roomId?: UUID;
+	entityId?: UUID;
+	title?: string;
+	source?: TranscriptSource;
+	scope?: TranscriptScope;
+	segments: TranscriptSegment[];
+	audioUrl?: string;
+	audioContentType?: string;
+	/** Base64 WAV bytes — persisted to the media store; sets audioUrl. */
+	audioBase64?: string;
+	createdAt?: number;
+}
+
+/**
+ * Build a full {@link Transcript} from a create request — derives duration +
+ * speaker count from the segments, defaults title/scope/status. Pure (id + now
+ * injected) so it is unit-testable.
+ */
+export function buildTranscriptFromRequest(
+	body: CreateTranscriptRequest,
+	id: string,
+	now: number,
+): Transcript {
+	const segments = Array.isArray(body.segments) ? body.segments : [];
+	const createdAt = body.createdAt ?? now;
+	return {
+		id,
+		title: body.title?.trim() || defaultTitle(createdAt),
+		createdAt,
+		endedAt: now,
+		durationMs: transcriptDurationMs(segments),
+		audioUrl: body.audioUrl,
+		audioContentType: body.audioContentType,
+		segments,
+		source: body.source ?? "voice-session",
+		scope: body.scope ?? "owner-private",
+		status: "ready",
+		speakerCount: transcriptSpeakerCount(segments),
+	};
+}
+
+function defaultTitle(createdAt: number): string {
+	return `Recording ${new Date(createdAt).toLocaleString()}`;
+}
+
+const listRoute: Route = {
+	type: "GET",
+	path: "/api/transcripts",
+	rawPath: true,
+	routeHandler: async (ctx): Promise<RouteHandlerResult> => {
+		const roomId = (ctx.query.roomId as string | undefined) || undefined;
+		const transcripts = await service(ctx).list(roomId as UUID | undefined);
+		return { status: 200, body: { transcripts } };
+	},
+};
+
+const getRoute: Route = {
+	type: "GET",
+	path: "/api/transcripts/:id",
+	rawPath: true,
+	routeHandler: async (ctx): Promise<RouteHandlerResult> => {
+		const transcript = await service(ctx).get(ctx.params.id as UUID);
+		if (!transcript) return { status: 404, body: { error: "not found" } };
+		return { status: 200, body: { transcript } };
+	},
+};
+
+const deleteRoute: Route = {
+	type: "DELETE",
+	path: "/api/transcripts/:id",
+	rawPath: true,
+	routeHandler: async (ctx): Promise<RouteHandlerResult> => {
+		await service(ctx).delete(ctx.params.id as UUID);
+		return { status: 200, body: { ok: true } };
+	},
+};
+
+/** The body a transcript editor PUTs to persist a user edit. */
+export interface UpdateTranscriptRequest {
+	worldId?: UUID;
+	roomId?: UUID;
+	entityId?: UUID;
+	title?: string;
+	segments?: TranscriptSegment[];
+}
+
+const updateRoute: Route = {
+	type: "PUT",
+	path: "/api/transcripts/:id",
+	rawPath: true,
+	routeHandler: async (ctx): Promise<RouteHandlerResult> => {
+		const body = (ctx.body ?? {}) as UpdateTranscriptRequest;
+		if (body.title === undefined && body.segments === undefined) {
+			return { status: 400, body: { error: "title or segments is required" } };
+		}
+		if (body.segments !== undefined && !Array.isArray(body.segments)) {
+			return { status: 400, body: { error: "segments must be an array" } };
+		}
+		const agentId = ctx.runtime.agentId as UUID;
+		const updated = await service(ctx).update(ctx.params.id as UUID, {
+			worldId: (body.worldId ?? agentId) as UUID,
+			roomId: (body.roomId ?? agentId) as UUID,
+			entityId: (body.entityId ?? agentId) as UUID,
+			patch: { title: body.title, segments: body.segments },
+		});
+		if (!updated) return { status: 404, body: { error: "not found" } };
+		return { status: 200, body: { transcript: updated } };
+	},
+};
+
+const createRoute: Route = {
+	type: "POST",
+	path: "/api/transcripts",
+	rawPath: true,
+	routeHandler: async (ctx): Promise<RouteHandlerResult> => {
+		const body = ctx.body as CreateTranscriptRequest | undefined;
+		if (!body || !Array.isArray(body.segments) || body.segments.length === 0) {
+			return { status: 400, body: { error: "segments are required" } };
+		}
+		// The shell client doesn't carry world/room/entity ids — default them to
+		// the agent context (single-user local) when not supplied.
+		const agentId = ctx.runtime.agentId as UUID;
+		// Persist the recorded session WAV into the served media store so the
+		// player has audio to scrub. The shell sends base64 (it can't write files).
+		if (body.audioBase64 && !body.audioUrl) {
+			body.audioUrl = persistTranscriptAudioWav(
+				Buffer.from(body.audioBase64, "base64"),
+			);
+			body.audioContentType = "audio/wav";
+		}
+		const transcript = buildTranscriptFromRequest(
+			body,
+			crypto.randomUUID(),
+			Date.now(),
+		);
+		const saved = await service(ctx).create({
+			worldId: (body.worldId ?? agentId) as UUID,
+			roomId: (body.roomId ?? agentId) as UUID,
+			entityId: (body.entityId ?? agentId) as UUID,
+			transcript,
+		});
+		return { status: 201, body: { transcript: saved } };
+	},
+};
+
+export const transcriptsRoutes: Route[] = [
+	listRoute,
+	createRoute,
+	getRoute,
+	updateRoute,
+	deleteRoute,
+];