@vellumai/assistant 0.11.4-staging.1 → 0.11.4-staging.2

package/openapi.yaml

@@ -3,7 +3,7 @@
 openapi: 3.1.0
 info:
   title: Vellum Assistant API
-  version: 0.11.4
+  version: 0.11.3
   description: Auto-generated OpenAPI specification for the Vellum Assistant runtime HTTP server.
 servers:
   - url: http://127.0.0.1:7821

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vellumai/assistant",
-  "version": "0.11.4-staging.1",
+  "version": "0.11.4-staging.2",
   "license": "MIT",
   "type": "module",
   "exports": {

package/src/__tests__/byok-default-profile-ensure.test.ts

@@ -282,11 +282,26 @@ describe("ensureByokDefaultProfiles", () => {
     ["openai", "quality-optimized", "gpt-5.4"],
     ["fireworks", "balanced", "accounts/fireworks/models/kimi-k2p5"],
     ["fireworks", "balanced", "accounts/fireworks/models/kimi-k2p6"],
+    [
+      "fireworks",
+      "balanced",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
     [
       "fireworks",
       "quality-optimized",
       "accounts/fireworks/models/deepseek-v4-flash",
     ],
+    [
+      "fireworks",
+      "quality-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash-0731",
+    ],
+    [
+      "fireworks",
+      "cost-optimized",
+      "accounts/fireworks/models/deepseek-v4-flash",
+    ],
   ] as const)(
     "a historical intent-era copy converts (%s %s pinned to %s)",
     (provider, key, model) => {

package/src/__tests__/conversation-queue.test.ts

@@ -11,6 +11,7 @@ import type {
 } from "../agent/loop.js";
 import type { AssistantEvent } from "../api/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
+import { broadcastMessage } from "../runtime/assistant-event-hub.js";
 import { stampAndBuffer } from "../runtime/assistant-stream-state.js";
 import { createAbortReason } from "../util/abort-reasons.js";
 import { setConfig } from "./helpers/set-config.js";
@@ -3923,3 +3924,124 @@ describe("subagent notification user_message_echo suppression", () => {
     await new Promise((r) => setTimeout(r, 10));
   });
 });
+
+describe("interactive drain sender rebind", () => {
+  beforeEach(() => {
+    pendingRuns = [];
+  });
+
+  test("a drained interactive message rebinds the hub sender for its turn, then restores the pre-drain state", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    // Queue an interactive item the way the /v1/messages route does when the
+    // conversation is busy.
+    const result = conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: true,
+    });
+    expect(result.queued).toBe(true);
+
+    // The interactive turn that finishes ahead of the drain resets the
+    // conversation-level sender to a no-op (process-message.ts contract).
+    // The drained turn must not inherit that dead sender: the
+    // PermissionPrompter reads the conversation-level sender, so a
+    // confirmation_request raised during the drained turn would otherwise
+    // reach no client and hang until the permission timeout.
+    conversation.updateClient(() => {}, true);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+
+    await resolveRun(1);
+    await waitForCondition(
+      () => conversation.getCurrentSender() !== broadcastMessage,
+    );
+    expect(conversation.hasNoClient).toBe(true);
+  });
+
+  test("a drained interactive message restores a live pre-drain binding instead of clearing it", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: true,
+    });
+
+    // A live binding predates the drained turn (the send route installs one
+    // when a message is queued behind a non-interactive turn, which performs
+    // no restore). The drain's restore must preserve it for out-of-turn
+    // producers (call transcript and completion notifiers), not clear it.
+    conversation.updateClient(broadcastMessage, false);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+
+    await resolveRun(1);
+    // The drained turn has ended; the pre-drain live binding must survive.
+    await waitForCondition(() => !conversation.isProcessing());
+    expect(conversation.getCurrentSender()).toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(false);
+  });
+
+  test("a drained non-interactive message leaves the no-op sender in place", async () => {
+    const conversation = makeConversation();
+    await conversation.loadFromDb();
+
+    const p1 = conversation.processMessage({
+      content: "msg-1",
+      attachments: [],
+      onEvent: () => {},
+      requestId: "req-1",
+    });
+    await waitForPendingRun(1);
+
+    conversation.enqueueMessage({
+      content: "msg-2",
+      requestId: "req-2",
+      onEvent: () => {},
+      isInteractive: false,
+    });
+
+    conversation.updateClient(() => {}, true);
+
+    await resolveRun(0);
+    await p1;
+    await waitForPendingRun(2);
+
+    expect(conversation.getCurrentSender()).not.toBe(broadcastMessage);
+    expect(conversation.hasNoClient).toBe(true);
+
+    await resolveRun(1);
+    await new Promise((r) => setTimeout(r, 10));
+  });
+});

package/src/__tests__/ui-shape-teaching.test.ts

@@ -5,6 +5,7 @@ import { uiShowTool } from "../tools/ui-surface/definitions.js";
 import {
   SURFACE_SHAPE_DOCS,
   SURFACE_TYPE_NAMES,
+  UI_SHOW_TYPE_DOCS,
   uiShowTeachingError,
 } from "../tools/ui-surface/surface-shape-docs.js";
 
@@ -290,6 +291,12 @@ describe("ui_show displayable payloads proxy through", () => {
         surfaceType: "channel_setup",
         input: { surface_type: "channel_setup", data: { channel: "telegram" } },
       },
+      {
+        // The picker reads its own voice and catalog, so an empty payload is
+        // the whole contract and there is no missing-content state to teach.
+        surfaceType: "voice_picker",
+        input: { surface_type: "voice_picker", data: {} },
+      },
     ];
 
   for (const { surfaceType, input } of cases) {
@@ -347,4 +354,30 @@ describe("uiShowTeachingError", () => {
       expect(uiShowTool.description).toContain(name);
     }
   });
+
+  test("voice_picker is a cold type that accepts an empty payload", () => {
+    expect(
+      uiShowTeachingError({ surface_type: "voice_picker", data: {} }),
+    ).toBeNull();
+    expect(UI_SHOW_TYPE_DOCS).toContain(
+      `voice_picker (${SURFACE_SHAPE_DOCS.voice_picker!.purpose})`,
+    );
+    expect(UI_SHOW_TYPE_DOCS).not.toContain("- voice_picker:");
+  });
+
+  test("voice_picker steering reaches the model through the cold index", () => {
+    // Asserted on the built description rather than the doc entry: a cold
+    // type's `shape` reaches the model only through a teaching error, and an
+    // empty payload has no missing-content state to raise one, so steering
+    // parked there would be dead.
+    for (const directive of [
+      "change, hear, or pick a voice",
+      "rather than describing voices in prose",
+      "attach no actions and never set await_action",
+      "during a live voice call answer in speech",
+    ]) {
+      expect(UI_SHOW_TYPE_DOCS).toContain(directive);
+      expect(uiShowTool.description).toContain(directive);
+    }
+  });
 });

package/src/__tests__/ui-voice-picker-surface.test.ts

@@ -0,0 +1,128 @@
+/**
+ * Tests for the `voice_picker` ui_show surface's "never blocks a turn"
+ * invariant.
+ *
+ * The card has no terminal action: it settles when the user picks a voice,
+ * with no button to click. `actions` and `await_action` are generic ui_show
+ * params though, so the model can attach them to any surface, and the web
+ * client latches `awaiting_user_input` on the presence of actions alone with
+ * nothing to clear it. The daemon resolver therefore strips both, and a
+ * pending picker never holds the one-interactive-surface lock.
+ */
+
+import { describe, expect, test } from "bun:test";
+
+import { UISurfaceShowEventSchema } from "../api/events/ui-surface-show.js";
+import type { AssistantEvent } from "../api/index.js";
+import type { Conversation } from "../daemon/conversation.js";
+import {
+  createSurfaceMutex,
+  surfaceProxyResolver,
+} from "../daemon/conversation-surfaces.js";
+import type { SurfaceType } from "../daemon/message-protocol.js";
+import { INTERACTIVE_SURFACE_TYPES } from "../daemon/message-protocol.js";
+import { asConversation } from "./helpers/mock-conversation.js";
+
+function makeContext(sent: AssistantEvent[] = []): Conversation {
+  return asConversation({
+    conversationId: "session-1",
+    sendToClient: (msg) => sent.push(msg),
+    pendingSurfaceActions: new Map<string, { surfaceType: SurfaceType }>(),
+    lastSurfaceAction: new Map<
+      string,
+      { actionId: string; data?: Record<string, unknown> }
+    >(),
+    surfaceState: new Map(),
+    surfaceUndoStacks: new Map<string, string[]>(),
+    accumulatedSurfaceState: new Map<string, Record<string, unknown>>(),
+    surfaceActionRequestIds: new Set<string>(),
+    currentTurnSurfaces: [],
+    isProcessing: () => false,
+    enqueueMessage: () => ({ queued: false, requestId: "req-1" }),
+    getQueueDepth: () => 0,
+    processMessage: async () => "ok",
+    withSurface: createSurfaceMutex(),
+  });
+}
+
+function showEvent(sent: AssistantEvent[]) {
+  return UISurfaceShowEventSchema.parse(
+    sent.find((msg) => msg.type === "ui_surface_show"),
+  );
+}
+
+describe("voice_picker never blocks a turn", () => {
+  test("shows with an empty payload and awaits nothing", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+
+    const parsed = showEvent(sent);
+    expect(parsed.surfaceType).toBe("voice_picker");
+    expect(parsed.actions).toBeUndefined();
+    expect(ctx.pendingSurfaceActions.has(parsed.surfaceId)).toBe(false);
+  });
+
+  test("strips actions the model attached", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+      actions: [{ id: "done", label: "Done", style: "primary" }],
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+
+    const parsed = showEvent(sent);
+    expect(parsed.actions).toBeUndefined();
+    // The persisted copy must match the emitted one, or a history reseed would
+    // resurrect the button the client blocks on.
+    expect(ctx.currentTurnSurfaces[0]?.actions).toBeUndefined();
+    expect(ctx.pendingSurfaceActions.has(parsed.surfaceId)).toBe(false);
+  });
+
+  test("ignores an explicit await_action", async () => {
+    const sent: AssistantEvent[] = [];
+    const ctx = makeContext(sent);
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "voice_picker",
+      data: {},
+      await_action: true,
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.yieldToUser).toBeUndefined();
+    expect(result.content).not.toContain("awaiting_user_action");
+    expect(ctx.pendingSurfaceActions.size).toBe(0);
+  });
+
+  test("a pending picker does not hold the one-interactive-surface lock", async () => {
+    const ctx = makeContext();
+    ctx.pendingSurfaceActions.set("surface-picker", {
+      surfaceType: "voice_picker",
+    });
+
+    const result = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "choice",
+      data: { options: [{ id: "a", title: "Option A" }] },
+    });
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("already awaiting user input");
+  });
+
+  test("voice_picker is not an interactive surface type", () => {
+    expect(INTERACTIVE_SURFACE_TYPES).not.toContain("voice_picker");
+  });
+});

package/src/__tests__/voice-config-update.test.ts

@@ -276,6 +276,46 @@ describe("voice_config_update — tts_voice_id (managed/vellum active)", () => {
     expect(result.content).not.toContain("broadcast");
   });
 
+  test("hints the inline picker for the next managed voice change", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "aura-2-zeus-en" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).toStartWith("Vellum managed voice updated to");
+    expect(result.content).toContain(
+      'ui_show { surface_type: "voice_picker", data: {} }',
+    );
+  });
+
+  test("does not hint the picker when the voice is not managed", async () => {
+    writeConfig({ services: { tts: { provider: "elevenlabs" } } });
+    invalidateConfigCache();
+
+    const result = await run(
+      { setting: "tts_voice_id", value: "abc123" },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
+  test("does not hint the picker for a non-voice setting", async () => {
+    makeVellumActive();
+
+    const result = await run(
+      { setting: "conversation_timeout", value: 30 },
+      makeContext(),
+    );
+
+    expect(result.isError).toBe(false);
+    expect(result.content).not.toContain("voice_picker");
+  });
+
   test("rejects a value with characters invalid for any voice id", async () => {
     makeVellumActive();
 

package/src/__tests__/workspace-migration-146-repair-retired-fireworks-deepseek-flash-model-id.test.ts

@@ -0,0 +1,235 @@
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Database } from "bun:sqlite";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+
+import { repairRetiredFireworksDeepseekFlashModelIdMigration } from "../workspace/migrations/146-repair-retired-fireworks-deepseek-flash-model-id.js";
+import { WORKSPACE_MIGRATIONS } from "../workspace/migrations/registry.js";
+import { assertNotLiveDb } from "./assert-not-live-db.js";
+
+const STALE = "accounts/fireworks/models/deepseek-v4-flash";
+const REPLACEMENT = "accounts/fireworks/models/deepseek-v4-flash-0731";
+
+let workspaceDir: string;
+
+function freshWorkspace(): void {
+  workspaceDir = join(
+    tmpdir(),
+    `vellum-migration-146-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+  );
+  mkdirSync(workspaceDir, { recursive: true });
+}
+
+function writeConfig(data: Record<string, unknown>): void {
+  writeFileSync(
+    join(workspaceDir, "config.json"),
+    JSON.stringify(data, null, 2) + "\n",
+  );
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(join(workspaceDir, "config.json"), "utf-8"));
+}
+
+function seedRows(rows: Array<{ name: string; provider: string }>): void {
+  mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+  const db = new Database(join(workspaceDir, "data", "db", "assistant.db"));
+  db.run(`CREATE TABLE IF NOT EXISTS provider_connections (
+    name TEXT PRIMARY KEY,
+    provider TEXT NOT NULL,
+    auth TEXT NOT NULL,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+  )`);
+  for (const row of rows) {
+    db.query(
+      `INSERT INTO provider_connections (name, provider, auth, created_at, updated_at) VALUES (?, ?, '{"type":"api_key"}', 1, 1)`,
+    ).run(row.name, row.provider);
+  }
+  db.close();
+}
+
+beforeEach(() => {
+  freshWorkspace();
+});
+
+afterEach(() => {
+  if (existsSync(workspaceDir)) {
+    assertNotLiveDb(workspaceDir);
+    rmSync(workspaceDir, { recursive: true, force: true });
+  }
+});
+
+describe("146-repair-retired-fireworks-deepseek-flash-model-id migration", () => {
+  test("has correct migration id and is registered", () => {
+    expect(repairRetiredFireworksDeepseekFlashModelIdMigration.id).toBe(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+    expect(WORKSPACE_MIGRATIONS.map((m) => m.id)).toContain(
+      "146-repair-retired-fireworks-deepseek-flash-model-id",
+    );
+  });
+
+  test("repairs the stale ID in default, call sites, and profiles", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        callSites: {
+          recall: { model: STALE, maxTokens: 4096 },
+          heartbeat: { model: `${STALE}-tuned` },
+          malformed: STALE,
+        },
+        profiles: {
+          "cost-optimized": { provider: "vellum", model: STALE },
+          legacy: { model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.model).toBe(REPLACEMENT);
+    expect(llm.callSites.recall.maxTokens).toBe(4096);
+    // Non-exact matches and malformed leaves are untouched. The dated
+    // replacement itself extends the stale ID, so the exact match must not
+    // fire on already-repaired leaves.
+    expect(llm.callSites.heartbeat.model).toBe(`${STALE}-tuned`);
+    expect(llm.callSites.malformed).toBe(STALE);
+    // Managed profiles stamped provider "vellum" carry Fireworks model IDs.
+    expect(llm.profiles["cost-optimized"].model).toBe(REPLACEMENT);
+    expect(llm.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("repairs entry-bound fragments whose row kind is fireworks or vellum", () => {
+    seedRows([
+      { name: "my-fireworks", provider: "fireworks" },
+      { name: "managed-alt", provider: "vellum" },
+    ]);
+    writeConfig({
+      llm: {
+        profiles: {
+          bound: { provider: "my-fireworks", model: STALE },
+          managed: { provider: "managed-alt", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(REPLACEMENT);
+    expect(llm.profiles.managed.model).toBe(REPLACEMENT);
+  });
+
+  test("leaves fragments with an explicit other provider untouched", () => {
+    seedRows([{ name: "byo-compat", provider: "openai-compatible" }]);
+    writeConfig({
+      llm: {
+        default: { provider: "openai-compatible", model: STALE },
+        profiles: {
+          byo: { provider: "openai-compatible", model: STALE },
+          // Entry-bound profile whose row kind is not repairable.
+          compatBound: { provider: "byo-compat", model: STALE },
+          // Entry name with no row: dangling, so nothing proves it is a
+          // fireworks-kind route.
+          dangling: { provider: "ghost", model: STALE },
+        },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.default.model).toBe(STALE);
+    expect(llm.profiles.byo.model).toBe(STALE);
+    expect(llm.profiles.compatBound.model).toBe(STALE);
+    expect(llm.profiles.dangling.model).toBe(STALE);
+  });
+
+  test("leaves entry-name providers untouched when no DB file exists", () => {
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+  });
+
+  test("throws when an entry-name provider needs rows and the DB is unreadable", () => {
+    // A DB file without the provider_connections table is unqueryable, so
+    // the run must fail (and retry later) instead of skipping the profile.
+    mkdirSync(join(workspaceDir, "data", "db"), { recursive: true });
+    writeFileSync(join(workspaceDir, "data", "db", "assistant.db"), "");
+    writeConfig({
+      llm: {
+        profiles: { bound: { provider: "my-fireworks", model: STALE } },
+      },
+    });
+
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).toThrow();
+    const llm = readConfig().llm as Record<string, any>;
+    expect(llm.profiles.bound.model).toBe(STALE);
+
+    // Vendor and absent providers never need the rows, so the same broken
+    // DB does not block their repair.
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { legacy: { model: STALE } },
+      },
+    });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const repaired = readConfig().llm as Record<string, any>;
+    expect(repaired.default.model).toBe(REPLACEMENT);
+    expect(repaired.profiles.legacy.model).toBe(REPLACEMENT);
+  });
+
+  test("is idempotent and a no-op without the stale ID", () => {
+    writeConfig({
+      llm: {
+        default: { provider: "fireworks", model: STALE },
+        profiles: { fine: { provider: "fireworks", model: REPLACEMENT } },
+      },
+    });
+
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    const first = readConfig();
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual(first);
+
+    const llm = first.llm as Record<string, any>;
+    expect(llm.default.model).toBe(REPLACEMENT);
+    expect(llm.profiles.fine.model).toBe(REPLACEMENT);
+  });
+
+  test("handles missing config, missing llm block, and invalid JSON", () => {
+    // No config.json at all.
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+
+    writeConfig({ theme: "dark" });
+    repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir);
+    expect(readConfig()).toEqual({ theme: "dark" });
+
+    writeFileSync(join(workspaceDir, "config.json"), "{not json");
+    expect(() =>
+      repairRetiredFireworksDeepseekFlashModelIdMigration.run(workspaceDir),
+    ).not.toThrow();
+  });
+});

package/src/api/surfaces.ts

@@ -591,6 +591,7 @@ export const SURFACE_TYPES = [
   "skill_card",
   "call_summary",
   "visual",
+  "voice_picker",
 ] as const;
 
 export const SurfaceTypeSchema = z.enum(SURFACE_TYPES);
@@ -662,9 +663,10 @@ export type SurfaceData =
  * and serves verbatim but whose shape it does not model, which is why they
  * are absent from the renderable `SurfaceData` union: `channel_setup` (a
  * side-effect command forwarded to the setup panel), `task_preferences` (a
- * fixed grid that reads no data), and `skill_card` / `call_summary` (cards
- * the daemon appends to history directly — the memory retrospective and a
- * call summary — and whose data shape is owned by their client renderers).
+ * fixed grid that reads no data), `voice_picker` (a settings card that reads
+ * its own config), and `skill_card` / `call_summary` (cards the daemon appends
+ * to history directly, the memory retrospective and a call summary, whose
+ * data shape is owned by their client renderers).
  */
 export interface SurfaceDataByType {
   card: CardSurfaceData;
@@ -684,6 +686,7 @@ export interface SurfaceDataByType {
   skill_card: Record<string, unknown>;
   call_summary: Record<string, unknown>;
   visual: VisualSurfaceData;
+  voice_picker: Record<string, unknown>;
 }
 
 /** Any surface `data` payload, including the opaque (non-renderable) types. */
@@ -717,6 +720,7 @@ export const SURFACE_DATA_SCHEMAS: {
   skill_card: z.record(z.string(), z.unknown()),
   call_summary: z.record(z.string(), z.unknown()),
   visual: VisualSurfaceDataSchema,
+  voice_picker: z.record(z.string(), z.unknown()),
 };
 
 /**