@vellumai/assistant 0.10.12 → 0.11.0-staging.2

package/src/__tests__/assistant-event-hub.test.ts

@@ -1,6 +1,6 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   AssistantEventHub,
   broadcastMessage,
@@ -12,7 +12,9 @@ import {
 } from "../runtime/assistant-stream-state.js";
 import * as pendingInteractions from "../runtime/pending-interactions.js";
 
-function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
+function makeEvent(
+  overrides: Partial<AssistantEventEnvelope> = {},
+): AssistantEventEnvelope {
   return {
     id: "evt_test",
     conversationId: "sess_1",
@@ -31,7 +33,7 @@ function makeEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
 describe("AssistantEventHub — fanout", () => {
   test("delivers event to a single matching subscriber", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -75,8 +77,8 @@ describe("AssistantEventHub — fanout", () => {
 
   test("conversationId filter further restricts delivery", async () => {
     const hub = new AssistantEventHub();
-    const receivedA: AssistantEvent[] = [];
-    const receivedB: AssistantEvent[] = [];
+    const receivedA: AssistantEventEnvelope[] = [];
+    const receivedB: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -101,7 +103,7 @@ describe("AssistantEventHub — fanout", () => {
 
   test("subscriber without conversationId filter receives all conversations", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -159,7 +161,7 @@ describe("AssistantEventHub — fanout", () => {
 describe("AssistantEventHub — unsubscribe cleanup", () => {
   test("dispose stops event delivery", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
 
     const s = hub.subscribe({
       type: "process",
@@ -234,8 +236,8 @@ describe("AssistantEventHub — unsubscribe cleanup", () => {
 
   test("disposing one subscription does not affect others", async () => {
     const hub = new AssistantEventHub();
-    const received1: AssistantEvent[] = [];
-    const received2: AssistantEvent[] = [];
+    const received1: AssistantEventEnvelope[] = [];
+    const received2: AssistantEventEnvelope[] = [];
 
     const s1 = hub.subscribe({
       type: "process",
@@ -341,7 +343,7 @@ describe("AssistantEventHub — exception isolation", () => {
 describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
   test("subscriber added during publish does not receive the in-flight event", async () => {
     const hub = new AssistantEventHub();
-    const lateReceived: AssistantEvent[] = [];
+    const lateReceived: AssistantEventEnvelope[] = [];
 
     hub.subscribe({
       type: "process",
@@ -363,7 +365,7 @@ describe("AssistantEventHub — re-entrancy / snapshot isolation", () => {
 
   test("subscriber that disposes itself mid-publish does not affect remaining subscribers", async () => {
     const hub = new AssistantEventHub();
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     let s: ReturnType<typeof hub.subscribe>;
 
     // eslint-disable-next-line prefer-const

package/src/__tests__/assistant-event.test.ts

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import {
   formatSseFrame,
   formatSseHeartbeat,
@@ -8,9 +8,9 @@ import {
 
 // ── Type / shape tests ────────────────────────────────────────────────────────
 
-describe("AssistantEvent shape", () => {
+describe("AssistantEventEnvelope shape", () => {
   test("accepts a minimal valid event", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_001",
       emittedAt: "2026-02-18T21:20:00.000Z",
       message: {
@@ -27,7 +27,7 @@ describe("AssistantEvent shape", () => {
   });
 
   test("accepts a full event with conversationId", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       id: "evt_002",
       conversationId: "conv_456",
       emittedAt: "2026-02-18T21:20:00.000Z",
@@ -45,7 +45,7 @@ describe("AssistantEvent shape", () => {
 // ── SSE framing tests ─────────────────────────────────────────────────────────
 
 describe("formatSseFrame", () => {
-  const baseEvent: AssistantEvent = {
+  const baseEvent: AssistantEventEnvelope = {
     id: "evt_003",
     conversationId: "sess_xyz",
     emittedAt: "2026-02-18T00:00:00.000Z",
@@ -73,7 +73,7 @@ describe("formatSseFrame", () => {
     const dataLine = frame.split("\n").find((l) => l.startsWith("data: "))!;
     const parsed = JSON.parse(
       dataLine.slice("data: ".length),
-    ) as AssistantEvent;
+    ) as AssistantEventEnvelope;
 
     expect(parsed.id).toBe(baseEvent.id);
     expect(parsed.conversationId).toBe(baseEvent.conversationId);
@@ -82,13 +82,16 @@ describe("formatSseFrame", () => {
   });
 
   test("id line uses the event id verbatim", () => {
-    const event: AssistantEvent = { ...baseEvent, id: "unique-evt-id-xyz" };
+    const event: AssistantEventEnvelope = {
+      ...baseEvent,
+      id: "unique-evt-id-xyz",
+    };
     const frame = formatSseFrame(event);
     expect(frame).toContain("id: unique-evt-id-xyz\n");
   });
 
   test("strips newline characters from event.id to prevent SSE frame injection", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       ...baseEvent,
       id: 'foo\ndata: {"injected":true}',
     };
@@ -113,7 +116,7 @@ describe("formatSseFrame", () => {
   });
 
   test("seq lands in the JSON payload (envelope) when set, never in SSE id", () => {
-    const event: AssistantEvent = {
+    const event: AssistantEventEnvelope = {
       ...baseEvent,
       id: "uuid-event-id",
       seq: 42,

package/src/__tests__/assistant-feature-flag-guard.test.ts

@@ -7,7 +7,7 @@ import { describe, expect, test } from "bun:test";
  * Guard tests for assistant feature flags.
  *
  * 1. Key format validation: ensure production code uses the canonical
- *    simple kebab-case format (e.g., "browser", "voice-mode"), not the
+ *    simple kebab-case format (e.g., "browser", "contacts"), not the
  *    legacy `skills.<id>.enabled` format.
  *
  * 2. Declaration coverage: ensure all assistant-scope flag keys in the
@@ -123,7 +123,7 @@ describe("assistant feature flag guard", () => {
     if (violations.length > 0) {
       const message = [
         "Found production files using the legacy `skills.<id>.enabled` key format.",
-        'New code must use the canonical simple kebab-case format (e.g., "browser", "voice-mode").',
+        'New code must use the canonical simple kebab-case format (e.g., "browser", "contacts").',
         'See AGENTS.md "Assistant Feature Flags" for the convention.',
         "",
         "Violations:",
@@ -153,7 +153,7 @@ describe("assistant feature flag guard", () => {
     if (violations.length > 0) {
       const message = [
         "Found assistant-scope keys in the unified registry that do not match the canonical format.",
-        'Expected format: simple kebab-case (e.g., "browser", "voice-mode")',
+        'Expected format: simple kebab-case (e.g., "browser", "contacts")',
         "",
         "Violations:",
         ...violations.map((k) => `  - ${k}`),

package/src/__tests__/assistant-feature-flag-guardrails.test.ts

@@ -2,7 +2,7 @@
  * Guard tests for assistant feature flag conventions:
  *
  * 1. Key format: all feature flag keys used in production code must use
- *    simple kebab-case format (e.g., "browser", "voice-mode"). Any remaining
+ *    simple kebab-case format (e.g., "browser", "contacts"). Any remaining
  *    `skills.<id>.enabled` usage outside of migration/backward-compat code is
  *    flagged — including template literal forms like `skills.${skillId}.enabled`.
  *

package/src/__tests__/assistant-id-boundary-guard.test.ts

@@ -312,64 +312,6 @@ describe("assistant ID boundary", () => {
   // surfaces invites callers to pass external IDs into daemon scoping.
   // -------------------------------------------------------------------------
 
-  test("message contract types do not contain assistantId for guardian requests", () => {
-    const contractPath = join(
-      import.meta.dir,
-      "..",
-      "daemon",
-      "message-types",
-      "integrations.ts",
-    );
-    const content = readFileSync(contractPath, "utf-8");
-
-    // Extract the interface blocks for the request types and verify
-    // none of them declare an assistantId property.
-    const requestTypeNames = ["ChannelVerificationSessionRequest"];
-
-    for (const typeName of requestTypeNames) {
-      // Find the interface/type block — match from the type name to the next
-      // closing brace at the same indentation level. We use a simple heuristic:
-      // find the line declaring the type, then scan forward to the closing '}'.
-      const typeIndex = content.indexOf(typeName);
-      expect(
-        typeIndex,
-        `Expected to find ${typeName} in message contract`,
-      ).toBeGreaterThan(-1);
-
-      // Extract from the type declaration to the next '}' line
-      const blockStart = content.indexOf("{", typeIndex);
-      if (blockStart === -1) continue;
-      let braceDepth = 0;
-      let blockEnd = blockStart;
-      for (let i = blockStart; i < content.length; i++) {
-        if (content[i] === "{") braceDepth++;
-        if (content[i] === "}") braceDepth--;
-        if (braceDepth === 0) {
-          blockEnd = i + 1;
-          break;
-        }
-      }
-      const block = content.slice(blockStart, blockEnd);
-
-      // The block should not contain an assistantId property declaration
-      // (matches "assistantId?" or "assistantId:" on a non-comment line)
-      const lines = block.split("\n");
-      for (const line of lines) {
-        const trimmed = line.trim();
-        if (
-          trimmed.startsWith("//") ||
-          trimmed.startsWith("*") ||
-          trimmed.startsWith("/*")
-        )
-          continue;
-        expect(
-          /\bassistantId\s*[?:]/.test(trimmed),
-          `${typeName} must not declare an assistantId property. Found: "${trimmed}"`,
-        ).toBe(false);
-      }
-    }
-  });
-
   test("guardian outbound param interfaces do not contain assistantId", () => {
     const actionsPath = join(
       import.meta.dir,

package/src/__tests__/assistant-stream-state.test.ts

@@ -8,7 +8,7 @@ import {
 import { dirname, join } from "node:path";
 import { beforeEach, describe, expect, test } from "bun:test";
 
-import type { AssistantEvent } from "../runtime/assistant-event.js";
+import type { AssistantEventEnvelope } from "../api/index.js";
 import type {
   EventTargeting,
   ReplaySubscriber,
@@ -26,7 +26,9 @@ import {
 
 const CONV = "conv_test";
 
-function mkEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
+function mkEvent(
+  overrides: Partial<AssistantEventEnvelope> = {},
+): AssistantEventEnvelope {
   const conversationId =
     "conversationId" in overrides ? overrides.conversationId : CONV;
   return {
@@ -39,7 +41,7 @@ function mkEvent(overrides: Partial<AssistantEvent> = {}): AssistantEvent {
       text: "x",
     },
     ...overrides,
-  } as AssistantEvent;
+  } as AssistantEventEnvelope;
 }
 
 describe("assistant-stream-state", () => {
@@ -142,7 +144,9 @@ describe("assistant-stream-state", () => {
 
   describe("ring buffer eviction", () => {
     test("evicts oldest entries past the 200-event count cap", () => {
-      for (let i = 0; i < 250; i++) stampAndBuffer(mkEvent());
+      for (let i = 0; i < 250; i++) {
+        stampAndBuffer(mkEvent());
+      }
       const peek = _peekStreamForTesting();
       expect(peek.ringLength).toBe(200);
       // Newest is 250, oldest should be 51 (250 - 200 + 1)
@@ -212,7 +216,9 @@ describe("assistant-stream-state", () => {
 
     test("returns null when lastSeenSeq is older than oldest buffered entry", () => {
       // Force eviction by pushing past the count cap.
-      for (let i = 0; i < 250; i++) stampAndBuffer(mkEvent());
+      for (let i = 0; i < 250; i++) {
+        stampAndBuffer(mkEvent());
+      }
       const peek = _peekStreamForTesting();
       expect(peek.oldestSeq).toBe(51);
       // Client claims to have last seen seq=10 — that's far below oldest.
@@ -730,7 +736,9 @@ describe("assistant-stream-state", () => {
 
     test("stamping within a reserved block does not advance the persisted ceiling", () => {
       // GIVEN many stamps within one block
-      for (let i = 0; i < 100; i++) stampAndBuffer(mkEvent());
+      for (let i = 0; i < 100; i++) {
+        stampAndBuffer(mkEvent());
+      }
 
       // WHEN the daemon restarts
       _simulateRestartForTesting();
@@ -784,7 +792,9 @@ describe("assistant-stream-state", () => {
 
       // Stamp past the 200-event ring cap so the restarted process's
       // earliest events are genuinely evicted.
-      for (let i = 0; i < 205; i++) stampAndBuffer(mkEvent());
+      for (let i = 0; i < 205; i++) {
+        stampAndBuffer(mkEvent());
+      }
 
       // The gap now includes evicted post-restart events, so replay must
       // signal the snapshot fallback.

package/src/__tests__/avatar-identity-sync.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, test } from "bun:test";
 
+import type { AssistantEventEnvelope } from "../api/index.js";
 import { SYNC_TAGS } from "../daemon/message-types/sync.js";
-import type { AssistantEvent } from "../runtime/assistant-event.js";
 import { assistantEventHub } from "../runtime/assistant-event-hub.js";
 import { ROUTES as AVATAR_ROUTES } from "../runtime/routes/avatar-routes.js";
 import { publishIdentityChanged } from "../runtime/sync/resource-sync-events.js";
@@ -19,7 +19,7 @@ async function waitFor(predicate: () => boolean): Promise<void> {
 
 describe("avatar and identity sync events", () => {
   test("notify_avatar_updated emits legacy avatar event and sync tag", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {
@@ -50,7 +50,7 @@ describe("avatar and identity sync events", () => {
   });
 
   test("identity changes emit legacy identity event and identity sync tags", async () => {
-    const received: AssistantEvent[] = [];
+    const received: AssistantEventEnvelope[] = [];
     const subscription = assistantEventHub.subscribe({
       type: "process",
       callback: (event) => {

package/src/__tests__/background-workers-disk-pressure.test.ts

@@ -151,6 +151,7 @@ mock.module("../persistence/jobs-store.js", () => ({
   MESSAGE_LEXICAL_JOB_TYPES: [],
   rescheduleMemoryJob: mock(() => {}),
   resetRunningJobsToPending: mock(() => 0),
+  upsertEmbedGraphNodeJob: mock(() => "job-embed-node"),
   SLOW_LLM_JOB_TYPES: [],
   upsertDebouncedJob: mock(() => "job-debounced"),
   upsertMemoryRetrospectiveJob: mock(() => "job-memory-retrospective"),

package/src/__tests__/call-conversation-messages.test.ts

@@ -9,10 +9,11 @@ import {
   recordCallEvent,
   updateCallSession,
 } from "../calls/call-store.js";
-import { getMessages } from "../persistence/conversation-crud.js";
+import { addMessage, getMessages } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
 import { conversations } from "../persistence/schema/index.js";
+import { contentBlockArraySchema } from "../providers/content-block-schema.js";
 
 await initializeDb();
 
@@ -38,25 +39,57 @@ function resetTables(): void {
   db.run("DELETE FROM conversations");
 }
 
-function getLatestAssistantText(conversationId: string): string {
-  const rows = getMessages(conversationId).filter(
-    (m) => m.role === "assistant",
-  );
+type PersistedBlock = {
+  type: string;
+  text?: string;
+  surfaceType?: string;
+  surfaceId?: string;
+  data?: { summaryText?: string };
+  _surfaceFallback?: boolean;
+};
+
+/**
+ * The blocks of the latest assistant message carrying a `call_summary` card.
+ *
+ * Selecting on the card rather than on "latest assistant row" keeps these
+ * assertions independent of rows other test files leave in the shared
+ * workspace DB when the suite runs as one process.
+ */
+function getLatestAssistantBlocks(conversationId: string): PersistedBlock[] {
+  const rows = getMessages(conversationId).filter((m) => {
+    if (m.role !== "assistant") {
+      return false;
+    }
+    const blocks = m.content as unknown as PersistedBlock[];
+    return (
+      Array.isArray(blocks) &&
+      blocks.some(
+        (b) => b.type === "ui_surface" && b.surfaceType === "call_summary",
+      )
+    );
+  });
   expect(rows.length).toBeGreaterThan(0);
-  const latest = rows[rows.length - 1];
-  const parsed = latest.content as unknown as Array<{
-    type: string;
-    text?: string;
-    surfaceType?: string;
-    data?: { summaryText?: string };
-  }>;
+  return rows[rows.length - 1].content as unknown as PersistedBlock[];
+}
+
+/**
+ * The message's model-visible copy. A call summary persists as a
+ * `[ui_surface, text]` pair carrying the SAME sentence, so text blocks win and
+ * the card is read only for legacy rows that predate the fallback sibling —
+ * concatenating both would double the summary.
+ */
+function getLatestAssistantText(conversationId: string): string {
+  const parsed = getLatestAssistantBlocks(conversationId);
+  const text = parsed
+    .filter((b) => b.type === "text")
+    .map((b) => b.text ?? "")
+    .join("");
+  if (text) {
+    return text;
+  }
   return parsed
-    .map((b) => {
-      if (b.type === "text") return b.text ?? "";
-      if (b.type === "ui_surface" && b.surfaceType === "call_summary")
-        return b.data?.summaryText ?? "";
-      return "";
-    })
+    .filter((b) => b.type === "ui_surface" && b.surfaceType === "call_summary")
+    .map((b) => b.data?.summaryText ?? "")
     .join("");
 }
 
@@ -127,4 +160,87 @@ describe("call-conversation-messages", () => {
       "**Call completed**. 1 event(s) recorded.",
     );
   });
+
+  test("persistCallCompletionMessage pairs the card with a flagged text fallback", async () => {
+    // Every provider drops `ui_surface` when serializing history, so the card
+    // alone left the model unable to tell that a call happened — the turn
+    // reached the wire as a "blocks omitted" sentinel (LUM-2869). The
+    // `_surfaceFallback` sibling is what carries the summary to the model,
+    // search indexing, CLI display, and channel replies; its flag keeps
+    // surface-capable clients from rendering the card AND a duplicate line.
+    const conversationId = "conv-call-msg-fallback";
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: "twilio",
+      fromNumber: "+12025550101",
+      toNumber: "+12025550102",
+    });
+
+    updateCallSession(session.id, { status: "in_progress", startedAt: 1_000 });
+    updateCallSession(session.id, { status: "completed", endedAt: 43_000 });
+    recordCallEvent(session.id, "call_ended");
+
+    const summary = await persistCallCompletionMessage(
+      conversationId,
+      session.id,
+    );
+    const blocks = getLatestAssistantBlocks(conversationId);
+
+    expect(blocks).toHaveLength(2);
+    const [surface, fallback] = blocks;
+
+    expect(surface!.type).toBe("ui_surface");
+    expect(surface!.surfaceType).toBe("call_summary");
+    expect(surface!.surfaceId).toBeTruthy();
+    expect(surface!.data?.summaryText).toBe(summary);
+
+    expect(fallback!.type).toBe("text");
+    expect(fallback!._surfaceFallback).toBe(true);
+    expect(fallback!.text).toBe(summary);
+    expect(fallback!.text).toContain("(42s)");
+  });
+
+  test("persisted call-summary blocks satisfy the ContentBlock schema", async () => {
+    // The pair is JSON-serialized straight into `messages.content`. If it did
+    // not validate, every read of the row would pay the per-block repair —
+    // the read-path noise that spiked with voice GA (LUM-2869).
+    const conversationId = "conv-call-msg-schema";
+    ensureConversation(conversationId);
+    const session = createCallSession({
+      conversationId,
+      provider: "twilio",
+      fromNumber: "+12025550101",
+      toNumber: "+12025550102",
+    });
+    updateCallSession(session.id, { status: "completed" });
+    recordCallEvent(session.id, "call_ended");
+    await persistCallCompletionMessage(conversationId, session.id);
+
+    const blocks = getLatestAssistantBlocks(conversationId);
+    expect(contentBlockArraySchema.safeParse(blocks).success).toBe(true);
+  });
+
+  test("persisting a card-only message throws in tests (model-invisible guard)", async () => {
+    // The guard in `insertMessageCore` is what stops LUM-2869 recurring: a
+    // producer that persists a card with no model-readable sibling fails its
+    // own suite instead of silently shipping turns the model cannot see.
+    // (In production the same condition only warns — never-block posture.)
+    const conversationId = "conv-card-only-guard";
+    ensureConversation(conversationId);
+    await expect(
+      addMessage(
+        conversationId,
+        "assistant",
+        JSON.stringify([
+          {
+            type: "ui_surface",
+            surfaceId: "bare-1",
+            surfaceType: "call_summary",
+            data: { summaryText: "orphaned card" },
+          },
+        ]),
+      ),
+    ).rejects.toThrow(/only content is ui_surface/);
+  });
 });

package/src/__tests__/call-start-guardian-guard.test.ts

@@ -111,3 +111,30 @@ describe("call_start guardian verification guard", () => {
     expect(startCallInputs.length).toBe(1);
   });
 });
+
+describe("call tools — model-input schema validation (LUM-2856)", () => {
+  test("call_start rejects a non-string phone_number before reaching startCall", async () => {
+    const before = startCallInputs.length;
+    const result = await executeCallStart(
+      { phone_number: 4155550100, task: "call someone" },
+      makeContext(),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain('Invalid input for tool "call_start"');
+    expect(result.content).toContain("phone_number");
+    expect(startCallInputs.length).toBe(before);
+  });
+
+  test("call_start rejects an unknown caller_identity_mode", async () => {
+    const result = await executeCallStart(
+      {
+        phone_number: "+14155550100",
+        task: "call someone",
+        caller_identity_mode: "spoofed",
+      },
+      makeContext(),
+    );
+    expect(result.isError).toBe(true);
+    expect(result.content).toContain("caller_identity_mode");
+  });
+});

package/src/__tests__/channel-approvals.test.ts

@@ -17,7 +17,6 @@ import type { PendingApprovalInfo } from "../runtime/channel-approvals.js";
 import {
   buildApprovalUIMetadata,
   buildGuardianApprovalPrompt,
-  channelSupportsRichApprovalUI,
   getChannelApprovalPrompt,
   handleChannelDecision,
 } from "../runtime/channel-approvals.js";
@@ -343,29 +342,3 @@ describe("buildGuardianApprovalPrompt", () => {
     expect(prompt.actions.map((a) => a.id)).toEqual(["approve_once", "reject"]);
   });
 });
-
-// ═══════════════════════════════════════════════════════════════════════════
-// 5. channelSupportsRichApprovalUI
-// ═══════════════════════════════════════════════════════════════════════════
-
-describe("channelSupportsRichApprovalUI", () => {
-  test("returns true for telegram", () => {
-    expect(channelSupportsRichApprovalUI("telegram")).toBe(true);
-  });
-
-  test("returns false for vellum", () => {
-    expect(channelSupportsRichApprovalUI("vellum")).toBe(false);
-  });
-
-  test("returns false for voice", () => {
-    expect(channelSupportsRichApprovalUI("phone")).toBe(false);
-  });
-
-  test("returns true for slack", () => {
-    expect(channelSupportsRichApprovalUI("slack")).toBe(true);
-  });
-
-  test("returns false for unknown channels", () => {
-    expect(channelSupportsRichApprovalUI("")).toBe(false);
-  });
-});