@vellumai/assistant 0.12.0 → 0.12.1-dev.202609142113.d1590bc

package/src/i18n/__tests__/i18n.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, test } from "bun:test";
+
+import {
+  DEFAULT_LOCALE,
+  isMessageKey,
+  localeFromAcceptLanguage,
+  MESSAGE_CATALOGS,
+  MESSAGE_KEYS,
+  negotiateLocale,
+  resolveConversationTitle,
+  SUPPORTED_LOCALES,
+  t,
+} from "../index.js";
+
+describe("negotiateLocale", () => {
+  test("matches a full shipped tag", () => {
+    expect(negotiateLocale(["es"])).toBe("es");
+    expect(negotiateLocale(["zh-TW"])).toBe("zh-TW");
+  });
+
+  test("falls back from a regional tag to the primary language", () => {
+    expect(negotiateLocale(["es-MX", "en"])).toBe("es");
+  });
+
+  test("maps Traditional Chinese tags to zh-TW", () => {
+    expect(negotiateLocale(["zh-Hant"])).toBe("zh-TW");
+    expect(negotiateLocale(["zh-HK"])).toBe("zh-TW");
+  });
+
+  test("defaults when nothing matches", () => {
+    expect(negotiateLocale([])).toBe(DEFAULT_LOCALE);
+    expect(negotiateLocale(["xx"])).toBe(DEFAULT_LOCALE);
+  });
+});
+
+describe("localeFromAcceptLanguage", () => {
+  test("honors quality values", () => {
+    expect(localeFromAcceptLanguage("fr;q=0.8, es;q=0.9, en;q=0.5")).toBe(
+      "es",
+    );
+  });
+
+  test("defaults on missing or empty", () => {
+    expect(localeFromAcceptLanguage(null)).toBe(DEFAULT_LOCALE);
+    expect(localeFromAcceptLanguage("")).toBe(DEFAULT_LOCALE);
+  });
+});
+
+describe("catalog completeness", () => {
+  test("every locale has every key", () => {
+    const keys = Object.values(MESSAGE_KEYS);
+    for (const locale of SUPPORTED_LOCALES) {
+      for (const key of keys) {
+        expect(MESSAGE_CATALOGS[locale][key].length).toBeGreaterThan(0);
+      }
+    }
+  });
+});
+
+describe("t", () => {
+  test("resolves generating and untitled per locale", () => {
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING, "en")).toBe(
+      "Generating title...",
+    );
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, "en")).toBe(
+      "Untitled Conversation",
+    );
+    expect(t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, "es")).toBe(
+      "Sin título",
+    );
+  });
+});
+
+describe("resolveConversationTitle", () => {
+  test("resolves a stored key and an empty title", () => {
+    expect(
+      resolveConversationTitle(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING, "zh"),
+    ).toBe("标题生成中...");
+    expect(resolveConversationTitle(null, "es")).toBe("Sin título");
+    expect(resolveConversationTitle("")).toBe("Untitled Conversation");
+  });
+
+  test("passes stored display strings through, including English placeholders", () => {
+    expect(resolveConversationTitle("Untitled Conversation", "es")).toBe(
+      "Untitled Conversation",
+    );
+    expect(resolveConversationTitle("Generating title...", "zh")).toBe(
+      "Generating title...",
+    );
+    expect(resolveConversationTitle("Auth Middleware Rewrite", "es")).toBe(
+      "Auth Middleware Rewrite",
+    );
+  });
+
+  test("defaults locale inside the helper", () => {
+    expect(
+      resolveConversationTitle(MESSAGE_KEYS.CONVERSATION_TITLE_GENERATING),
+    ).toBe("Generating title...");
+  });
+});
+
+describe("isMessageKey", () => {
+  test("recognizes catalog keys only", () => {
+    expect(isMessageKey(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED)).toBe(true);
+    expect(isMessageKey("Untitled Conversation")).toBe(false);
+    expect(isMessageKey("Untitled")).toBe(false);
+  });
+});

package/src/i18n/index.ts

@@ -0,0 +1,16 @@
+export {
+  DEFAULT_LOCALE,
+  isSupportedLocale,
+  localeFromAcceptLanguage,
+  negotiateLocale,
+  SUPPORTED_LOCALES,
+  type SupportedLocale,
+} from "./locales.js";
+export {
+  isMessageKey,
+  MESSAGE_CATALOGS,
+  MESSAGE_KEYS,
+  type MessageKey,
+  t,
+} from "./messages.js";
+export { resolveConversationTitle } from "./title.js";

package/src/i18n/locales.ts

@@ -0,0 +1,93 @@
+/**
+ * Locales the daemon can resolve user-facing copy into.
+ *
+ * Keep this set aligned with `clients/web/src/i18n/supported-locales.ts`.
+ * A locale that exists only here cannot be requested by the web app; a
+ * locale that exists only there cannot be resolved for CLI or HTTP
+ * consumers that go through this module.
+ */
+
+export const DEFAULT_LOCALE = "en";
+
+export const SUPPORTED_LOCALES = ["en", "es", "ru", "zh", "zh-TW"] as const;
+
+export type SupportedLocale = (typeof SUPPORTED_LOCALES)[number];
+
+export function isSupportedLocale(value: unknown): value is SupportedLocale {
+  return (
+    typeof value === "string" &&
+    (SUPPORTED_LOCALES as readonly string[]).includes(value)
+  );
+}
+
+/**
+ * Pick the best shipped locale for an ordered list of preferred BCP 47 tags.
+ *
+ * Full tag first, then the primary language subtag, so `es-MX` resolves to
+ * `es`. `zh-Hant` / `zh-HK` / `zh-MO` map to `zh-TW`.
+ */
+export function negotiateLocale(preferred: readonly string[]): SupportedLocale {
+  for (const tag of preferred) {
+    const normalized = tag.trim();
+    if (normalized === "") {
+      continue;
+    }
+    const exact = SUPPORTED_LOCALES.find(
+      (locale) => locale.toLowerCase() === normalized.toLowerCase(),
+    );
+    if (exact) {
+      return exact;
+    }
+    const lower = normalized.toLowerCase();
+    if (
+      lower === "zh-hant" ||
+      lower.startsWith("zh-hant-") ||
+      lower === "zh-hk" ||
+      lower === "zh-mo"
+    ) {
+      return "zh-TW";
+    }
+    const base = normalized.split("-")[0]?.toLowerCase();
+    const baseMatched = SUPPORTED_LOCALES.find(
+      (locale) => locale.toLowerCase() === base,
+    );
+    if (baseMatched) {
+      return baseMatched;
+    }
+  }
+  return DEFAULT_LOCALE;
+}
+
+/**
+ * Parse an `Accept-Language` header into preference order and negotiate.
+ *
+ * Quality values are honored; the header is a hint, not a required input.
+ * Missing or empty headers resolve to {@link DEFAULT_LOCALE}.
+ */
+export function localeFromAcceptLanguage(
+  header: string | null | undefined,
+): SupportedLocale {
+  if (header == null || header.trim() === "") {
+    return DEFAULT_LOCALE;
+  }
+  const tags = header
+    .split(",")
+    .map((part) => {
+      const [tag, ...params] = part.trim().split(";");
+      let quality = 1;
+      for (const param of params) {
+        const [name, value] = param.trim().split("=");
+        if (name === "q" && value !== undefined) {
+          const parsed = Number.parseFloat(value);
+          if (Number.isFinite(parsed)) {
+            quality = parsed;
+          }
+        }
+      }
+      return { tag: tag?.trim() ?? "", quality };
+    })
+    .filter((entry) => entry.tag.length > 0)
+    .sort((a, b) => b.quality - a.quality)
+    .map((entry) => entry.tag);
+  return negotiateLocale(tags);
+}

package/src/i18n/messages.ts

@@ -0,0 +1,61 @@
+/**
+ * Daemon message catalog.
+ *
+ * Keys are the stable identity of a hardcoded constant. English is the
+ * source language. Add a key here, then add the same key to every locale
+ * catalog. A key present in a translated catalog but missing from English
+ * is a test failure.
+ *
+ * Persist the key when a column holds a system constant. Never persist a
+ * translated string, and never treat a stored display string as a key:
+ * a user title may be in any language.
+ */
+
+import {
+  DEFAULT_LOCALE,
+  type SupportedLocale,
+} from "./locales.js";
+
+export const MESSAGE_KEYS = {
+  CONVERSATION_TITLE_GENERATING: "conversation.title.generating",
+  CONVERSATION_TITLE_UNTITLED: "conversation.title.untitled",
+} as const;
+
+export type MessageKey = (typeof MESSAGE_KEYS)[keyof typeof MESSAGE_KEYS];
+
+export const MESSAGE_CATALOGS: Record<
+  SupportedLocale,
+  Record<MessageKey, string>
+> = {
+  en: {
+    "conversation.title.generating": "Generating title...",
+    "conversation.title.untitled": "Untitled Conversation",
+  },
+  es: {
+    "conversation.title.generating": "Generando título...",
+    "conversation.title.untitled": "Sin título",
+  },
+  ru: {
+    "conversation.title.generating": "Создание названия...",
+    "conversation.title.untitled": "Без названия",
+  },
+  zh: {
+    "conversation.title.generating": "标题生成中...",
+    "conversation.title.untitled": "无标题",
+  },
+  "zh-TW": {
+    "conversation.title.generating": "標題產生中...",
+    "conversation.title.untitled": "未命名",
+  },
+};
+
+export function t(
+  key: MessageKey,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  return MESSAGE_CATALOGS[locale][key] ?? MESSAGE_CATALOGS[DEFAULT_LOCALE][key];
+}
+
+export function isMessageKey(value: string): value is MessageKey {
+  return (Object.values(MESSAGE_KEYS) as string[]).includes(value);
+}

package/src/i18n/title.ts

@@ -0,0 +1,25 @@
+/**
+ * Resolve a conversation title for a locale.
+ *
+ * A stored message key (or an empty title) is a hardcoded constant and
+ * resolves through the catalog. Any other stored string is user or model
+ * copy and passes through, including English placeholders written before
+ * keys were persisted.
+ */
+
+import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
+import { isMessageKey, MESSAGE_KEYS, t } from "./messages.js";
+
+export function resolveConversationTitle(
+  title: string | null | undefined,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  const trimmed = title?.trim() ?? "";
+  if (trimmed === "") {
+    return t(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED, locale);
+  }
+  if (isMessageKey(trimmed)) {
+    return t(trimmed, locale);
+  }
+  return trimmed;
+}

package/src/inbound/platform-callback-registration.ts

@@ -18,9 +18,10 @@
  * the platform can register a route that points at this instance.
  */
 
-import { getPlatformAssistantId, getPlatformBaseUrl } from "../config/env.js";
+import { getPlatformBaseUrl } from "../config/env.js";
 import { getIsPlatform } from "../config/env-registry.js";
 import { getConfig } from "../config/loader.js";
+import { resolvePlatformAssistantId } from "../config/platform-identity.js";
 import { ipcRegisterWebhookRoute } from "../ipc/gateway-client.js";
 import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
@@ -45,11 +46,11 @@ export interface PlatformCallbackRegistrationContext {
 
 export async function resolvePlatformCallbackRegistrationContext(): Promise<PlatformCallbackRegistrationContext> {
   const platform = getIsPlatform();
-  const [storedBaseUrlRaw, storedAssistantIdRaw, storedAssistantApiKeyRaw] =
+  const [storedBaseUrlRaw, storedAssistantApiKeyRaw, assistantId] =
     await Promise.all([
       getSecureKeyAsync(credentialKey("vellum", "platform_base_url")),
-      getSecureKeyAsync(credentialKey("vellum", "platform_assistant_id")),
       getSecureKeyAsync(credentialKey("vellum", "assistant_api_key")),
+      resolvePlatformAssistantId(),
     ]);
 
   const storedBaseUrl = storedBaseUrlRaw?.trim();
@@ -57,8 +58,6 @@ export async function resolvePlatformCallbackRegistrationContext(): Promise<Plat
     /\/+$/,
     "",
   );
-  const assistantId =
-    getPlatformAssistantId().trim() || storedAssistantIdRaw?.trim() || "";
   const envAssistantCredential = process.env.ASSISTANT_API_KEY?.trim();
   const assistantCredential =
     storedAssistantApiKeyRaw?.trim() || envAssistantCredential || undefined;

package/src/live-voice/__tests__/live-voice-metrics.test.ts

@@ -329,7 +329,6 @@ describe("LiveVoiceMetricsCollector", () => {
       endpointHoldCount: 0,
       endpointDecisionMaxLatencyMs: 95,
     });
-    expect(completed).not.toHaveProperty("ackSpoken");
   });
 
   test("decisions without a source are attributed to the front door", () => {
@@ -435,7 +434,6 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(completed).not.toHaveProperty("endpointHoldCount");
     expect(completed).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(completed).not.toHaveProperty("endpointDecisionSource");
-    expect(completed).not.toHaveProperty("ackSpoken");
     expect(completed).not.toHaveProperty("progressUpdatesSpoken");
 
     const aggregateFields = getLiveVoiceMetricsAggregateFields(
@@ -446,7 +444,6 @@ describe("LiveVoiceMetricsCollector", () => {
     expect(aggregateFields).not.toHaveProperty("endpointHoldCount");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionMaxLatencyMs");
     expect(aggregateFields).not.toHaveProperty("endpointDecisionSource");
-    expect(aggregateFields).not.toHaveProperty("ackSpoken");
     expect(aggregateFields).not.toHaveProperty("progressUpdatesSpoken");
   });
 

package/src/live-voice/__tests__/live-voice-progress.test.ts

@@ -1,5 +1,14 @@
 import { describe, expect, mock, test } from "bun:test";
 
+import type {
+  VoiceProgressNarrator,
+  VoiceProgressTextInput,
+} from "../../calls/progress-narration.js";
+import {
+  pickProgressPhrase,
+  PROGRESS_FALLBACK_PHRASES,
+  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
+} from "../../calls/progress-phrases.js";
 import { sanitizeForTts } from "../../calls/tts-text-sanitizer.js";
 import type {
   VoiceTurnCallbacks,
@@ -7,9 +16,9 @@ import type {
 } from "../../calls/voice-session-bridge.js";
 import { loadRawConfig, saveRawConfig } from "../../config/loader.js";
 import type {
-  LiveVoiceFrontModelConfig,
-  LiveVoiceProgressConfig,
-} from "../../config/schemas/live-voice.js";
+  VoiceFrontModelConfig,
+  VoiceProgressConfig,
+} from "../../config/schemas/voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -21,15 +30,6 @@ import {
 } from "../live-voice-session.js";
 import type { LiveVoiceSessionFactoryContext } from "../live-voice-session-manager.js";
 import type { LiveVoiceTtsOptions } from "../live-voice-tts.js";
-import type {
-  VoiceProgressNarrator,
-  VoiceProgressTextInput,
-} from "../progress-narration.js";
-import {
-  pickProgressPhrase,
-  PROGRESS_FALLBACK_PHRASES,
-  PROGRESS_FALLBACK_PHRASES_BY_LANGUAGE,
-} from "../progress-phrases.js";
 import {
   createLiveVoiceServerFrameSequencer,
   type LiveVoiceClientStartFrame,
@@ -142,8 +142,8 @@ function makeProgressNarrator(
 }
 
 function progressConfig(
-  overrides: Partial<LiveVoiceProgressConfig> = {},
-): Partial<LiveVoiceFrontModelConfig> {
+  overrides: Partial<VoiceProgressConfig> = {},
+): Partial<VoiceFrontModelConfig> {
   const idleIntervalMs = overrides.idleIntervalMs ?? 60_000;
   return {
     progress: {
@@ -163,7 +163,7 @@ function progressConfig(
 }
 
 function createProgressHarness(options: {
-  frontModelConfig: Partial<LiveVoiceFrontModelConfig>;
+  frontModelConfig: Partial<VoiceFrontModelConfig>;
   progressNarrator: VoiceProgressNarrator;
   emitMetrics?: boolean;
   gateTtsText?: (text: string) => Promise<void> | null;

package/src/live-voice/__tests__/live-voice-sight-frame-echo.test.ts

@@ -0,0 +1,238 @@
+import { describe, expect, mock, spyOn, test } from "bun:test";
+
+import {
+  createMockProvider,
+  textResponse,
+} from "../../__tests__/helpers/mock-provider.js";
+import { setConfig } from "../../__tests__/helpers/set-config.js";
+import { waitFor } from "../../__tests__/helpers/wait-for.js";
+
+setConfig("memory", { enabled: false });
+
+import { UserMessageEchoEventSchema } from "../../api/events/user-message-echo.js";
+import type { AssistantEventEnvelope } from "../../api/index.js";
+import { Conversation } from "../../daemon/conversation.js";
+import * as conversationMessaging from "../../daemon/conversation-messaging.js";
+import {
+  deleteConversation,
+  setConversation,
+} from "../../daemon/conversation-registry.js";
+import { conversationMessagesSyncTag } from "../../daemon/message-types/sync.js";
+import { uploadAttachment } from "../../persistence/attachments-store.js";
+import * as conversationCrud from "../../persistence/conversation-crud.js";
+import { initializeDb } from "../../persistence/db-init.js";
+import { assistantEventHub } from "../../runtime/assistant-event-hub.js";
+import {
+  _drainFrameReclaimRechecksForTests,
+  _pendingFrameReclaimCountForTests,
+  persistAmbientSightFrame,
+  persistLiveVoicePhoto,
+} from "../live-voice-photo.js";
+import { LiveVoiceSession } from "../live-voice-session.js";
+import { createLiveVoiceServerFrameSequencer } from "../protocol.js";
+
+await initializeDb();
+
+function createHarness() {
+  const row = conversationCrud.createConversation("Camera frame echo");
+  const { provider } = createMockProvider([textResponse("")]);
+  const conversation = new Conversation(
+    row.id,
+    provider,
+    "system prompt",
+    () => {},
+    "/tmp",
+    { maxTokens: 4096 },
+  );
+  conversation.setTrustContext({
+    trustClass: "guardian",
+    sourceChannel: "vellum",
+  });
+  setConversation(row.id, conversation);
+
+  const sequencer = createLiveVoiceServerFrameSequencer();
+  const startVoiceTurn = mock(async () => ({
+    turnId: "turn-123",
+    abort: mock(),
+  }));
+  const session = new LiveVoiceSession(
+    {
+      sessionId: "session-123",
+      startFrame: {
+        type: "start",
+        conversationId: row.id,
+        audio: { mimeType: "audio/pcm", sampleRate: 24_000, channels: 1 },
+      },
+      sendFrame: async (payload) => sequencer.next(payload),
+    },
+    {
+      resolveTranscriber: async () => ({
+        providerId: "deepgram",
+        boundaryId: "daemon-streaming",
+        async start() {},
+        sendAudio() {},
+        stop() {},
+      }),
+      startVoiceTurn,
+      emitMetrics: false,
+    },
+  );
+  const published: {
+    event: AssistantEventEnvelope;
+    persistedIds: string[];
+    persistedSeq: number | null;
+  }[] = [];
+  const subscription = assistantEventHub.subscribe({
+    type: "process",
+    filter: { conversationId: row.id },
+    callback: (event) => {
+      if (
+        (event.message.type === "user_message_echo" &&
+          event.message.conversationId === row.id) ||
+        (event.message.type === "sync_changed" &&
+          event.message.tags.includes(conversationMessagesSyncTag(row.id)))
+      ) {
+        published.push({
+          event,
+          persistedIds: conversationCrud.getMessages(row.id).map((m) => m.id),
+          persistedSeq: conversationCrud.getConversationPersistedSeq(row.id),
+        });
+      }
+    },
+  });
+
+  return {
+    conversationId: row.id,
+    session,
+    startVoiceTurn,
+    published,
+    async dispose() {
+      subscription.dispose();
+      await session.close("client_end");
+      deleteConversation(row.id);
+      conversation.dispose();
+    },
+  };
+}
+
+async function uploadFrame(): Promise<string> {
+  const attachment = await uploadAttachment(
+    "frame.png",
+    "image/png",
+    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk",
+  );
+  return attachment.id;
+}
+
+async function expectAnnouncement(
+  harness: ReturnType<typeof createHarness>,
+  cameraFrame: boolean,
+): Promise<void> {
+  await waitFor(() => harness.published.length >= 2);
+  expect(harness.published.map(({ event }) => event.message.type)).toEqual([
+    "user_message_echo",
+    "sync_changed",
+  ]);
+  const [echo, sync] = harness.published;
+  const message = UserMessageEchoEventSchema.parse(echo.event.message);
+  const rows = conversationCrud.getMessages(harness.conversationId);
+  expect(rows).toHaveLength(1);
+  expect(message.messageId).toBe(rows[0].id);
+  expect(echo.persistedIds).toEqual([rows[0].id]);
+  expect(echo.event.seq).toBeNumber();
+  expect(sync.persistedSeq).toBe(echo.event.seq!);
+  expect(message.text).toBe(cameraFrame ? "(camera frame)" : "here's a photo:");
+  if (cameraFrame) {
+    expect(message.cameraFrame).toBe(true);
+  } else {
+    expect(echo.event.message).not.toHaveProperty("cameraFrame");
+  }
+  expect(harness.startVoiceTurn).not.toHaveBeenCalled();
+}
+
+describe("standalone image echoes", () => {
+  test.each(["sight_frame", "attach_image"] as const)(
+    "%s emits one committed row before the history invalidation",
+    async (type) => {
+      const harness = createHarness();
+      try {
+        await harness.session.start();
+        const attachmentId = await uploadFrame();
+        await harness.session.handleClientFrame({ type, attachmentId });
+        await expectAnnouncement(harness, type === "sight_frame");
+      } finally {
+        await harness.dispose();
+      }
+    },
+  );
+
+  test.each([
+    { kind: "sight_frame", deferred: false },
+    { kind: "photo", deferred: false },
+    { kind: "sight_frame", deferred: true },
+  ] as const)(
+    "$kind preserves its echo marker when a committed write throws (deferred: $deferred)",
+    async ({ kind, deferred }) => {
+      const harness = createHarness();
+      const realPersist = conversationMessaging.persistQueuedMessageBody;
+      const realGetMessage = conversationCrud.getMessageById;
+      let committed = false;
+      const persist = spyOn(
+        conversationMessaging,
+        "persistQueuedMessageBody",
+      ).mockImplementation(async (...args) => {
+        await realPersist(...args);
+        committed = true;
+        throw new Error("Post-insert write failed");
+      });
+      const read = spyOn(conversationCrud, "getMessageById").mockImplementation(
+        (...args) => {
+          if (deferred && committed) {
+            throw new Error("Store temporarily unreadable");
+          }
+          return realGetMessage(...args);
+        },
+      );
+      try {
+        const attachmentId = await uploadFrame();
+        const result =
+          kind === "sight_frame"
+            ? await persistAmbientSightFrame(
+                harness.conversationId,
+                attachmentId,
+                "voice",
+              )
+            : await persistLiveVoicePhoto(harness.conversationId, attachmentId);
+        expect(result.ok).toBe(!deferred);
+        if (deferred) {
+          expect(harness.published).toHaveLength(0);
+          expect(_pendingFrameReclaimCountForTests()).toBe(1);
+          _drainFrameReclaimRechecksForTests();
+          expect(_pendingFrameReclaimCountForTests()).toBe(1);
+          read.mockRestore();
+          _drainFrameReclaimRechecksForTests();
+          _drainFrameReclaimRechecksForTests();
+          expect(_pendingFrameReclaimCountForTests()).toBe(0);
+        }
+        await expectAnnouncement(harness, kind === "sight_frame");
+      } finally {
+        persist.mockRestore();
+        read.mockRestore();
+        _drainFrameReclaimRechecksForTests();
+        await harness.dispose();
+      }
+    },
+  );
+
+  test("the strict echo schema accepts only a true camera marker", () => {
+    const echo = { type: "user_message_echo", text: "(camera frame)" };
+    expect(
+      UserMessageEchoEventSchema.safeParse({ ...echo, cameraFrame: false })
+        .success,
+    ).toBe(false);
+    expect(
+      UserMessageEchoEventSchema.safeParse({ ...echo, unexpected: true })
+        .success,
+    ).toBe(false);
+  });
+});

package/src/live-voice/__tests__/live-voice-vad.test.ts

@@ -12,7 +12,7 @@ import {
   loadRawConfig,
   saveRawConfig,
 } from "../../config/loader.js";
-import type { LiveVoiceFrontModelConfig } from "../../config/schemas/live-voice.js";
+import type { VoiceFrontModelConfig } from "../../config/schemas/voice.js";
 import type {
   StreamingTranscriber,
   SttStreamServerEvent,
@@ -183,7 +183,7 @@ function createHarness(options: {
   echoBargeInMargin?: number;
   echoEmaHalfLifeMs?: number;
   echoDrainSlackMs?: number;
-  frontModelConfig?: Partial<LiveVoiceFrontModelConfig>;
+  frontModelConfig?: Partial<VoiceFrontModelConfig>;
   emitMetrics?: boolean;
   metricsClock?: () => number;
   // Return a promise to hold a frame's transport write open (a backed-up