@vellumai/assistant 0.12.5 → 0.12.6-dev.202609292116.41f7caa

package/src/followups/followup-store.ts

@@ -5,8 +5,6 @@ import { getDb } from "../persistence/db-connection.js";
 import { followups } from "../persistence/schema/index.js";
 import type { FollowUp, FollowUpCreateInput, FollowUpStatus } from "./types.js";
 
-// ── Helpers ──────────────────────────────────────────────────────────
-
 function parseFollowUp(row: typeof followups.$inferSelect): FollowUp {
   const scheduleId = row.reminderCronId;
   return {
@@ -23,8 +21,6 @@ function parseFollowUp(row: typeof followups.$inferSelect): FollowUp {
   };
 }
 
-// ── CRUD ─────────────────────────────────────────────────────────────
-
 export function createFollowUp(input: FollowUpCreateInput): FollowUp {
   const db = getDb();
   const now = Date.now();

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

@@ -8,6 +8,7 @@ import {
   MESSAGE_KEYS,
   negotiateLocale,
   resolveConversationTitle,
+  resolveStoredMessageText,
   SUPPORTED_LOCALES,
   t,
 } from "../index.js";
@@ -103,6 +104,30 @@ describe("resolveConversationTitle", () => {
   });
 });
 
+describe("resolveStoredMessageText", () => {
+  test("resolves exact stored keys while preserving surrounding whitespace", () => {
+    expect(
+      resolveStoredMessageText(
+        `\n\n${MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP}`,
+        "es",
+      ),
+    ).toBe(
+      `\n\n${
+        MESSAGE_CATALOGS.es[MESSAGE_KEYS.AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP]
+      }`,
+    );
+  });
+
+  test("passes legacy and ordinary display text through", () => {
+    const legacy =
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.";
+    expect(resolveStoredMessageText(legacy, "es")).toBe(legacy);
+    expect(resolveStoredMessageText("ordinary assistant text", "zh")).toBe(
+      "ordinary assistant text",
+    );
+  });
+});
+
 describe("isMessageKey", () => {
   test("recognizes catalog keys only", () => {
     expect(isMessageKey(MESSAGE_KEYS.CONVERSATION_TITLE_UNTITLED)).toBe(true);

package/src/i18n/assistant-text.ts

@@ -0,0 +1,18 @@
+/** Resolve persisted daemon-authored assistant text at a presentation edge. */
+
+import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
+import { isMessageKey, t } from "./messages.js";
+
+export function resolveStoredMessageText(
+  text: string,
+  locale: SupportedLocale = DEFAULT_LOCALE,
+): string {
+  const trimmed = text.trim();
+  if (!isMessageKey(trimmed)) {
+    return text;
+  }
+  const start = text.indexOf(trimmed);
+  return `${text.slice(0, start)}${t(trimmed, locale)}${text.slice(
+    start + trimmed.length,
+  )}`;
+}

package/src/i18n/index.ts

@@ -1,3 +1,4 @@
+export { resolveStoredMessageText } from "./assistant-text.js";
 export {
   DEFAULT_LOCALE,
   isSupportedLocale,

package/src/i18n/messages.ts

@@ -16,6 +16,7 @@ import { DEFAULT_LOCALE, type SupportedLocale } from "./locales.js";
 export const MESSAGE_KEYS = {
   CONVERSATION_TITLE_GENERATING: "conversation.title.generating",
   CONVERSATION_TITLE_UNTITLED: "conversation.title.untitled",
+  AGENT_LOOP_UNPARSEABLE_TOOL_RETRY_STOP: "agentLoop.unparseableToolRetryStop",
   PLUGIN_MCP_OAUTH_CREDENTIALS_UNCHECKED:
     "plugin.uninstall.mcp_oauth_credentials_unchecked",
 } as const;
@@ -27,30 +28,40 @@ export const MESSAGE_CATALOGS: Record<
   Record<MessageKey, string>
 > = {
   en: {
+    "agentLoop.unparseableToolRetryStop":
+      "I stopped after repeated malformed tool calls to keep this conversation from growing indefinitely. Please try again, or switch models if the problem continues.",
     "conversation.title.generating": "Generating title...",
     "conversation.title.untitled": "Untitled Conversation",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "Credential storage is unavailable, so historical plugin MCP OAuth credentials could not be checked.",
   },
   es: {
+    "agentLoop.unparseableToolRetryStop":
+      "Me detuve después de varias llamadas de herramienta con formato incorrecto para evitar que esta conversación creciera indefinidamente. Inténtalo de nuevo o cambia de modelo si el problema continúa.",
     "conversation.title.generating": "Generando título...",
     "conversation.title.untitled": "Sin título",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "El almacenamiento de credenciales no está disponible, por lo que no se pudieron comprobar las credenciales históricas de OAuth de MCP del plugin.",
   },
   ru: {
+    "agentLoop.unparseableToolRetryStop":
+      "Выполнение остановлено после нескольких некорректных вызовов инструментов, чтобы этот разговор не рос бесконечно. Попробуйте ещё раз или смените модель, если проблема не исчезнет.",
     "conversation.title.generating": "Создание названия...",
     "conversation.title.untitled": "Без названия",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "Хранилище учетных данных недоступно, поэтому не удалось проверить сохраненные учетные данные OAuth MCP плагина.",
   },
   zh: {
+    "agentLoop.unparseableToolRetryStop":
+      "在工具调用多次格式错误后，我已停止运行，以免此对话无限增长。请重试；如果问题仍然存在，请切换模型。",
     "conversation.title.generating": "标题生成中...",
     "conversation.title.untitled": "无标题",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":
       "凭据存储不可用，因此无法检查该插件之前的 MCP OAuth 凭据。",
   },
   "zh-TW": {
+    "agentLoop.unparseableToolRetryStop":
+      "在工具呼叫多次格式錯誤後，我已停止執行，以免此對話無限增長。請重試；如果問題仍然存在，請切換模型。",
     "conversation.title.generating": "標題產生中...",
     "conversation.title.untitled": "未命名",
     "plugin.uninstall.mcp_oauth_credentials_unchecked":

package/src/inbound/__tests__/oauth-callback-url.test.ts

@@ -21,19 +21,42 @@ mock.module("../platform-callback-registration.js", () => ({
 
 mock.module("../public-ingress-urls.js", () => ({
   getOAuthCallbackUrl: () => "https://direct.example/webhooks/oauth/callback",
+  getMcpOAuthClientMetadataUrl: () =>
+    "https://direct.example/oauth/client-metadata.json",
 }));
 
 mock.module("../../config/loader.js", () => ({
   loadConfig: () => ({}),
 }));
 
-const { OAUTH_CALLBACK_PATH, resolveOauthCallbackUrl } =
-  await import("../oauth-callback-url.js");
+const {
+  OAUTH_CALLBACK_PATH,
+  resolveMcpOAuthClientMetadataUrl,
+  resolveOauthCallbackUrl,
+} = await import("../oauth-callback-url.js");
 
 afterEach(() => {
   resolveCallbackUrl.mockClear();
 });
 
+describe("resolveMcpOAuthClientMetadataUrl", () => {
+  test("returns the metadata URL for the exact direct HTTPS callback", () => {
+    expect(
+      resolveMcpOAuthClientMetadataUrl(
+        "https://direct.example/webhooks/oauth/callback",
+      ),
+    ).toBe("https://direct.example/oauth/client-metadata.json");
+  });
+
+  test("returns undefined for a callback served somewhere else", () => {
+    expect(
+      resolveMcpOAuthClientMetadataUrl(
+        "https://platform.example/v1/gateway/callbacks/assistant-123/webhooks/oauth/callback",
+      ),
+    ).toBeUndefined();
+  });
+});
+
 describe("resolveOauthCallbackUrl", () => {
   test("returns whatever the shared resolver decides", async () => {
     await expect(resolveOauthCallbackUrl()).resolves.toEqual(

package/src/inbound/oauth-callback-url.ts

@@ -18,7 +18,10 @@
 
 import { loadConfig } from "../config/loader.js";
 import { resolveCallbackUrl } from "./platform-callback-registration.js";
-import { getOAuthCallbackUrl } from "./public-ingress-urls.js";
+import {
+  getMcpOAuthClientMetadataUrl,
+  getOAuthCallbackUrl,
+} from "./public-ingress-urls.js";
 
 /**
  * Path the gateway serves the shared OAuth callback on.
@@ -59,3 +62,29 @@ export async function resolveOauthCallbackUrl(): Promise<string> {
     OAUTH_REGISTRATION_TYPE,
   );
 }
+
+/**
+ * Return the public Client ID Metadata Document URL when it is compatible
+ * with the callback selected for this flow.
+ *
+ * A URL-based client id must be HTTPS, and its document must publish the exact
+ * redirect URI used by the authorization request. The gateway document is
+ * derived from public ingress, so a platform-relayed callback cannot use it.
+ * Returning undefined preserves Dynamic Client Registration as the SDK's
+ * fallback in either case.
+ */
+export function resolveMcpOAuthClientMetadataUrl(
+  redirectUrl: string,
+): string | undefined {
+  try {
+    const config = loadConfig();
+    if (getOAuthCallbackUrl(config) !== redirectUrl) {
+      return undefined;
+    }
+
+    const metadataUrl = getMcpOAuthClientMetadataUrl(config);
+    return new URL(metadataUrl).protocol === "https:" ? metadataUrl : undefined;
+  } catch {
+    return undefined;
+  }
+}

package/src/inbound/public-ingress-urls.ts

@@ -27,6 +27,10 @@
  * All public-facing ingress URL construction is centralized here.
  */
 
+import {
+  buildMcpOAuthCallbackUrl,
+  buildMcpOAuthClientMetadataUrl,
+} from "@vellumai/service-contracts/mcp-oauth";
 import {
   buildTwilioMediaStreamUrl,
   buildTwilioStatusWebhookUrl,
@@ -160,8 +164,14 @@ export function getTwilioMediaStreamUrl(config: IngressConfig): string {
  * Build the OAuth callback URL.
  */
 export function getOAuthCallbackUrl(config: IngressConfig): string {
-  const base = getPublicBaseUrl(config);
-  return `${base}/webhooks/oauth/callback`;
+  return buildMcpOAuthCallbackUrl(getPublicBaseUrl(config));
+}
+
+/**
+ * Build the public Client ID Metadata Document URL for MCP OAuth.
+ */
+export function getMcpOAuthClientMetadataUrl(config: IngressConfig): string {
+  return buildMcpOAuthClientMetadataUrl(getPublicBaseUrl(config));
 }
 
 /**

package/src/ipc/gateway-client.test.ts

@@ -19,6 +19,7 @@ import {
   ipcCallPersistent,
   ipcClassifyRisk,
   ipcGetFeatureFlags,
+  ipcGetVelayStatus,
   resetPersistentClient,
 } from "./gateway-client.js";
 
@@ -139,6 +140,45 @@ describe("ipcGetFeatureFlags", () => {
   });
 });
 
+describe("ipcGetVelayStatus", () => {
+  test("parses the shared Velay status response", async () => {
+    mockGatewayIpc(null, {
+      results: {
+        get_velay_status: {
+          connected: true,
+          publicUrl: "https://example.test",
+        },
+      },
+    });
+
+    expect(await ipcGetVelayStatus()).toEqual({
+      connected: true,
+      publicUrl: "https://example.test",
+    });
+  });
+
+  test("keeps connected status when publicUrl is malformed", async () => {
+    mockGatewayIpc(null, {
+      results: {
+        get_velay_status: { connected: false, publicUrl: 42 },
+      },
+    });
+
+    expect(await ipcGetVelayStatus()).toEqual({
+      connected: false,
+      publicUrl: null,
+    });
+  });
+
+  test("returns null when connected is missing or malformed", async () => {
+    mockGatewayIpc(null, {
+      results: { get_velay_status: { connected: "yes" } },
+    });
+
+    expect(await ipcGetVelayStatus()).toBeNull();
+  });
+});
+
 // ---------------------------------------------------------------------------
 // ipcClassifyRisk retry semantics
 // ---------------------------------------------------------------------------

package/src/ipc/gateway-client.ts

@@ -14,10 +14,13 @@ import {
   type ClassifyRiskIpcParams,
   type ClassifyRiskIpcResponse,
   ClassifyRiskIpcResponseSchema,
+  FeatureFlagsIpcResponseSchema,
   ListWebhookRoutesIpcResponseSchema,
   type RegisterWebhookRouteIpcParams,
   RegisterWebhookRouteIpcResponseSchema,
   UnregisterWebhookRouteIpcResponseSchema,
+  type VelayStatusIpcResponse,
+  VelayStatusIpcResponseSchema,
   type WebhookIngressRoute,
 } from "@vellumai/gateway-client";
 import {
@@ -148,46 +151,26 @@ export function resetPersistentClient(): void {
 export async function ipcGetFeatureFlags(
   timeoutMs?: number,
 ): Promise<Record<string, boolean | string>> {
-  const result = await ipcCall("get_feature_flags", undefined, timeoutMs);
-  if (result && typeof result === "object" && !Array.isArray(result)) {
-    const filtered: Record<string, boolean | string> = {};
-    for (const [k, v] of Object.entries(result as Record<string, unknown>)) {
-      if (typeof v === "boolean" || typeof v === "string") {
-        filtered[k] = v;
-      }
-    }
-    return filtered;
-  }
-  return {};
+  const parsed = FeatureFlagsIpcResponseSchema.safeParse(
+    await ipcCall("get_feature_flags", undefined, timeoutMs),
+  );
+  return parsed.success ? parsed.data : {};
 }
 
 // ---------------------------------------------------------------------------
 // Velay tunnel status
 // ---------------------------------------------------------------------------
 
-export interface VelayTunnelStatus {
-  connected: boolean;
-  publicUrl: string | null;
-}
-
 /**
  * Fetch the current Velay tunnel status from the gateway via IPC.
  * Returns `null` when the gateway is unreachable or returns an unexpected
  * response — callers should treat `null` as "gateway not running".
  */
-export async function ipcGetVelayStatus(): Promise<VelayTunnelStatus | null> {
-  const result = await ipcCall("get_velay_status");
-  if (!result || typeof result !== "object" || Array.isArray(result)) {
-    return null;
-  }
-  const obj = result as Record<string, unknown>;
-  if (typeof obj.connected !== "boolean") {
-    return null;
-  }
-  return {
-    connected: obj.connected,
-    publicUrl: typeof obj.publicUrl === "string" ? obj.publicUrl : null,
-  };
+export async function ipcGetVelayStatus(): Promise<VelayStatusIpcResponse | null> {
+  const parsed = VelayStatusIpcResponseSchema.safeParse(
+    await ipcCall("get_velay_status"),
+  );
+  return parsed.success ? parsed.data : null;
 }
 
 // ---------------------------------------------------------------------------

package/src/ipc/gateway-flag-listener.ts

@@ -26,6 +26,13 @@ function refreshFlagsAndReconcileProfiles(context: string): void {
       if (!loaded) {
         return;
       }
+      // Consumers read the synchronous flag cache in response to this event.
+      void publishSyncInvalidation([
+        SYNC_TAGS.featureFlagsClient,
+        SYNC_TAGS.featureFlagsAssistant,
+      ]).catch((err) => {
+        log.warn({ err }, "Failed to broadcast feature-flags sync_changed");
+      });
       if (reconcileFlagGatedProfiles()) {
         // Reuse the config-changed broadcast clients already consume: web
         // routes the `assistant:self:config` sync tag to the effective profile
@@ -65,16 +72,6 @@ function handleData(chunk: Buffer): void {
       if (msg.event === "feature_flags_changed") {
         log.info("Received feature_flags_changed event — refreshing overrides");
         refreshFlagsAndReconcileProfiles("flags-changed event");
-        // Fan out to every connected web client so React Query caches
-        // for `/v1/feature-flags/client-flag-values/` and
-        // `/v1/assistants/:id/feature-flags` invalidate immediately
-        // instead of waiting on a 5s polling tick.
-        publishSyncInvalidation([
-          SYNC_TAGS.featureFlagsClient,
-          SYNC_TAGS.featureFlagsAssistant,
-        ]).catch((err) => {
-          log.warn({ err }, "Failed to broadcast feature-flags sync_changed");
-        });
       }
     } catch {
       // Ignore non-JSON lines (e.g. IPC responses on a shared socket)

package/src/live-voice/__tests__/live-voice-agent-turn.test.ts

@@ -265,6 +265,77 @@ describe("LiveVoiceSession assistant turn", () => {
     },
   );
 
+  test("offers the newest snapshot of the shared surface's controls to the bridge, until the share ends", async () => {
+    const startVoiceTurn = mock(async (_options: VoiceTurnOptions) => ({
+      turnId: "bridge-turn-1",
+      abort: mock(),
+    }));
+    const { session, transcriber } = createSessionHarness({
+      startFrame: { ...START_FRAME, client: "macos" },
+      startVoiceTurn,
+    });
+    const snapshotNaming = (label: string) => ({
+      targets: [
+        {
+          id: `t-${label}`,
+          label,
+          role: "AXButton",
+          x: 0.8,
+          y: 0.05,
+          width: 0.05,
+          height: 0.03,
+        },
+      ],
+      total: 1,
+    });
+    await session.start();
+    await session.handleClientFrame({
+      type: "update_config",
+      screenSharing: true,
+    });
+    await session.handleClientFrame({
+      type: "update_config",
+      shareTargets: snapshotNaming("Filters"),
+    });
+    await session.handleClientFrame({
+      type: "update_config",
+      shareTargets: snapshotNaming("root_Filters"),
+    });
+    transcriber.emit({ type: "final", text: "Where is Filters?" });
+    await session.handleClientFrame({ type: "ptt_release" });
+    expect(startVoiceTurn.mock.calls[0]?.[0].shareTargets).toEqual(
+      snapshotNaming("root_Filters"),
+    );
+    await session.close("client_end");
+
+    // A share that ended takes its snapshot with it.
+    const ended = createSessionHarness({
+      startFrame: { ...START_FRAME, client: "macos" },
+      startVoiceTurn,
+    });
+    startVoiceTurn.mockClear();
+    await ended.session.start();
+    await ended.session.handleClientFrame({
+      type: "update_config",
+      screenSharing: true,
+      shareTargets: snapshotNaming("root_Filters"),
+    });
+    await ended.session.handleClientFrame({
+      type: "update_config",
+      screenSharing: false,
+    });
+    await ended.session.handleClientFrame({
+      type: "update_config",
+      screenSharing: true,
+    });
+    ended.transcriber.emit({ type: "final", text: "Where is Filters?" });
+    await ended.session.handleClientFrame({ type: "ptt_release" });
+    expect(startVoiceTurn.mock.calls[0]?.[0]).not.toHaveProperty(
+      "shareTargets",
+    );
+    await ended.session.close("client_end");
+  });
+
   test("runs final transcripts through the voice bridge and forwards ordered assistant events", async () => {
     const startVoiceTurn = mock(async (options: VoiceTurnOptions) => {
       options.callbacks?.assistant_text_delta?.({

package/src/live-voice/__tests__/live-voice-flux-turn-end.test.ts

@@ -1771,6 +1771,89 @@ describe("LiveVoiceSession Flux end-of-turn during the STT dial", () => {
     await session.close("client_end");
   }, 10_000);
 
+  test("rearms an empty fallback cycle while the previous reply is active", async () => {
+    const abort = mock();
+    const { frames, session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      startVoiceTurn: async (turnOptions) => {
+        turnOptions.callbacks?.assistant_text_delta?.(
+          makeTextDelta("Working on the edit."),
+        );
+        return { turnId: "editing-turn", abort };
+      },
+    });
+
+    try {
+      await session.start();
+      await waitFor(() => transcribers.length === 1);
+      const transcriber = transcribers[0]!;
+      await session.handleBinaryAudio(LOUD_CHUNK);
+      transcriber.startOfTurn(0);
+      transcriber.endOfTurn("edit the clip", 0);
+      await waitFor(() => turnCalls.length === 1);
+
+      const speechStarts = countFrames(frames, "speech_started");
+      await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+      // No provider speech start or transcript arrives for this local onset.
+      await waitFor(() => transcriber.stopped);
+      await waitFor(
+        () => transcribers.length >= 2,
+        "An empty fallback cycle blocked the replacement stream behind the reply",
+      );
+      expect(countFrames(frames, "utterance_discarded")).toBe(1);
+      expect(countFrames(frames, "speech_started")).toBe(speechStarts);
+      expect(countFrames(frames, "turn_cancelled")).toBe(0);
+      expect(abort).not.toHaveBeenCalled();
+      expect(turnCalls).toHaveLength(1);
+
+      const replacement = transcribers.at(-1)!;
+      await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+      expect(replacement.received.length).toBeGreaterThan(0);
+      replacement.startOfTurn(0);
+      await waitFor(() => countFrames(frames, "turn_cancelled") === 1);
+      expect(countFrames(frames, "speech_started")).toBe(speechStarts + 1);
+      expect(abort).toHaveBeenCalledTimes(1);
+
+      replacement.endOfTurn("stop editing", 0);
+      await waitFor(() => turnCalls.length === 2);
+      expect(turnCalls[1]?.content).toBe("stop editing");
+    } finally {
+      await session.close("client_end");
+    }
+  }, 10_000);
+
+  test("keeps a nonempty fallback transcript queued behind the previous reply", async () => {
+    const abort = mock();
+    const { frames, session, transcribers, turnCalls } = createHarness({
+      fluxConfig: FLUX_ON,
+      startVoiceTurn: async () => ({ turnId: "editing-turn", abort }),
+    });
+
+    try {
+      await session.start();
+      await waitFor(() => transcribers.length === 1);
+      const transcriber = transcribers[0]!;
+      await session.handleBinaryAudio(LOUD_CHUNK);
+      transcriber.startOfTurn(0);
+      transcriber.endOfTurn("edit the clip", 0);
+      await waitFor(() => turnCalls.length === 1);
+
+      transcriber.pendingFlushText = "show me the result";
+      await session.handleBinaryAudio(SUSTAINED_LOUD_CHUNK);
+      await waitFor(() => transcriber.stopped);
+      await flushAsyncCallbacks();
+      expect(turnCalls).toHaveLength(1);
+      expect(countFrames(frames, "utterance_discarded")).toBe(0);
+      expect(abort).not.toHaveBeenCalled();
+
+      turnCalls[0]?.callbacks?.message_complete?.(makeMessageComplete());
+      await waitFor(() => turnCalls.length === 2);
+      expect(turnCalls[1]?.content).toBe("show me the result");
+    } finally {
+      await session.close("client_end");
+    }
+  }, 10_000);
+
   test("routes a closing stream's flush into the turn it released", async () => {
     const { session, transcribers, turnCalls } = createHarness({
       fluxConfig: FLUX_ON,

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

@@ -88,6 +88,83 @@ describe("parseLiveVoiceClientTextFrame", () => {
     },
   );
 
+  test("parses the shared surface's controls, and a clear", () => {
+    const shareTargets = {
+      targets: [
+        {
+          id: "t1",
+          label: "root_Filters",
+          role: "AXButton",
+          section: "Toolbar",
+          x: 0.8,
+          y: 0.05,
+          width: 0.05,
+          height: 0.03,
+        },
+      ],
+      total: 3,
+    };
+    expect(
+      parseLiveVoiceClientTextFrame(
+        JSON.stringify({ type: "update_config", shareTargets }),
+      ),
+    ).toEqual({ ok: true, frame: { type: "update_config", shareTargets } });
+    expect(
+      parseLiveVoiceClientTextFrame(
+        JSON.stringify({ type: "update_config", shareTargets: null }),
+      ),
+    ).toEqual({
+      ok: true,
+      frame: { type: "update_config", shareTargets: null },
+    });
+  });
+
+  test("drops an off-shape control rather than refusing the snapshot", () => {
+    const result = parseLiveVoiceClientTextFrame(
+      JSON.stringify({
+        type: "update_config",
+        shareTargets: {
+          targets: [
+            {
+              id: "t1",
+              label: "Send",
+              role: "AXButton",
+              x: 2,
+              y: 0,
+              width: 0.1,
+              height: 0.1,
+            },
+            {
+              id: "t2",
+              label: "Save",
+              role: "AXButton",
+              x: 0.1,
+              y: 0.1,
+              width: 0.1,
+              height: 0.1,
+            },
+          ],
+          total: 2,
+        },
+      }),
+    );
+    expect(result.ok).toBe(true);
+    if (!result.ok || result.frame.type !== "update_config") {
+      return;
+    }
+    expect(result.frame.shareTargets?.targets.map((t) => t.label)).toEqual([
+      "Save",
+    ]);
+  });
+
+  test("rejects a snapshot with no targets array", () => {
+    expect(
+      parseLiveVoiceClientTextFrame(
+        JSON.stringify({ type: "update_config", shareTargets: { total: 1 } }),
+      ).ok,
+    ).toBe(false);
+  });
+
   test("rejects malformed screen sharing state", () => {
     expect(
       parseLiveVoiceClientTextFrame(