@vellumai/assistant 0.4.41 → 0.4.43

package/src/__tests__/chrome-cdp.test.ts

@@ -4,16 +4,19 @@ import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 // Mocks
 // ---------------------------------------------------------------------------
 
-// We need to mock child_process.spawn and the global fetch / WebSocket so
-// tests don't need a real Chrome process.
+// We need to mock child_process.spawn and execSync, and the global fetch /
+// WebSocket so tests don't need a real Chrome process.
 
 const spawnMock = mock(() => {
   const proc = { unref: mock(() => {}) };
   return proc;
 });
 
+const execSyncMock = mock(() => "");
+
 mock.module("node:child_process", () => ({
   spawn: spawnMock,
+  execSync: execSyncMock,
 }));
 
 const {
@@ -28,6 +31,17 @@ let fetchImpl: (url: string | URL | Request) => Promise<Response>;
 
 const originalFetch = globalThis.fetch;
 
+/** Helper: a fetchImpl that simulates a CDP endpoint with page targets. */
+function cdpReadyFetch(url: string | URL | Request): Promise<Response> {
+  const urlStr = String(url);
+  if (urlStr.includes("/json/list")) {
+    return Promise.resolve(
+      new Response(JSON.stringify([{ type: "page" }]), { status: 200 }),
+    );
+  }
+  return Promise.resolve(new Response("{}", { status: 200 }));
+}
+
 beforeEach(() => {
   // Default: CDP not ready
   fetchImpl = async () => {
@@ -40,6 +54,7 @@ beforeEach(() => {
     return fetchImpl(input);
   }) as typeof globalThis.fetch;
   spawnMock.mockClear();
+  execSyncMock.mockClear();
 });
 
 afterEach(() => {
@@ -51,8 +66,8 @@ afterEach(() => {
 // ---------------------------------------------------------------------------
 
 describe("isCdpReady", () => {
-  test("returns true when the endpoint responds with 200", async () => {
-    fetchImpl = async () => new Response("{}", { status: 200 });
+  test("returns true when the endpoint responds with 200 and has page targets", async () => {
+    fetchImpl = cdpReadyFetch;
     expect(await isCdpReady()).toBe(true);
   });
 
@@ -68,14 +83,33 @@ describe("isCdpReady", () => {
     expect(await isCdpReady()).toBe(false);
   });
 
+  test("returns false when CDP is up but has no page targets", async () => {
+    fetchImpl = async (url) => {
+      const urlStr = String(url);
+      if (urlStr.includes("/json/list")) {
+        return new Response("[]", { status: 200 });
+      }
+      return new Response("{}", { status: 200 });
+    };
+    expect(await isCdpReady()).toBe(false);
+  });
+
   test("uses the provided base URL", async () => {
-    let calledUrl = "";
+    const calledUrls: string[] = [];
     fetchImpl = async (url) => {
-      calledUrl = String(url);
+      const urlStr = String(url);
+      calledUrls.push(urlStr);
+      if (urlStr.includes("/json/list")) {
+        return new Response(JSON.stringify([{ type: "page" }]), {
+          status: 200,
+        });
+      }
       return new Response("{}", { status: 200 });
     };
     await isCdpReady("http://localhost:9333");
-    expect(calledUrl).toBe("http://localhost:9333/json/version");
+    expect(calledUrls.some((u) => u.startsWith("http://localhost:9333/"))).toBe(
+      true,
+    );
   });
 });
 
@@ -85,7 +119,7 @@ describe("isCdpReady", () => {
 
 describe("ensureChromeWithCdp", () => {
   test("returns immediately if CDP is already ready (launchedByUs=false)", async () => {
-    fetchImpl = async () => new Response("{}", { status: 200 });
+    fetchImpl = cdpReadyFetch;
     const session = await ensureChromeWithCdp();
     expect(session.launchedByUs).toBe(false);
     expect(session.baseUrl).toBe("http://localhost:9222");
@@ -94,10 +128,20 @@ describe("ensureChromeWithCdp", () => {
 
   test("spawns Chrome and retries when CDP is not initially ready", async () => {
     let callCount = 0;
-    fetchImpl = async () => {
+    fetchImpl = async (url) => {
       callCount++;
-      // Succeed on the 3rd call (1st check + 2 retries)
-      if (callCount >= 3) return new Response("{}", { status: 200 });
+      // First isCdpReady check fails (2 fetch calls: /json/version + /json/list).
+      // Stale-check /json/version also fails.
+      // After spawn, successive isCdpReady calls succeed on the 5th overall call.
+      if (callCount >= 5) {
+        const urlStr = String(url);
+        if (urlStr.includes("/json/list")) {
+          return new Response(JSON.stringify([{ type: "page" }]), {
+            status: 200,
+          });
+        }
+        return new Response("{}", { status: 200 });
+      }
       throw new Error("Connection refused");
     };
 
@@ -119,13 +163,13 @@ describe("ensureChromeWithCdp", () => {
   });
 
   test("uses custom port when specified", async () => {
-    fetchImpl = async () => new Response("{}", { status: 200 });
+    fetchImpl = cdpReadyFetch;
     const session = await ensureChromeWithCdp({ port: 9333 });
     expect(session.baseUrl).toBe("http://localhost:9333");
   });
 
   test("uses custom userDataDir when specified", async () => {
-    fetchImpl = async () => new Response("{}", { status: 200 });
+    fetchImpl = cdpReadyFetch;
     const session = await ensureChromeWithCdp({
       userDataDir: "/tmp/test-chrome",
     });
@@ -138,10 +182,6 @@ describe("ensureChromeWithCdp", () => {
       throw new Error("Connection refused");
     };
 
-    // Override the retry delay so the test doesn't take 15 seconds.
-    // We can't easily do that without changing the implementation, so we
-    // test a shorter scenario: just verify it throws eventually.
-    // For CI speed, we rely on the error message check.
     const promise = ensureChromeWithCdp();
     await expect(promise).rejects.toThrow("CDP endpoint not responding");
   }, 20_000);

package/src/__tests__/cli-help-reference-sync.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test } from "bun:test";
+
+import { buildCliProgram } from "../cli/program.js";
+import { CLI_HELP_REFERENCE } from "../cli/reference.js";
+
+/**
+ * Guard test: CLI_HELP_REFERENCE must stay in sync with the actual CLI help
+ * output produced by buildCliProgram().helpInformation().
+ *
+ * The snapshot in reference.ts is embedded in the system prompt (via
+ * system-prompt.ts) so the assistant knows which CLI commands are available.
+ * If the actual CLI program drifts from the snapshot, the system prompt will
+ * contain stale information.
+ *
+ * When this test fails, update CLI_HELP_REFERENCE in
+ * assistant/src/cli/reference.ts to match the current output of
+ * buildCliProgram().helpInformation().
+ */
+describe("CLI_HELP_REFERENCE sync", () => {
+  test("CLI_HELP_REFERENCE matches buildCliProgram().helpInformation()", () => {
+    const program = buildCliProgram();
+    const actual = program.helpInformation();
+
+    expect(actual).toBe(CLI_HELP_REFERENCE);
+  });
+});

package/src/__tests__/compaction.benchmark.test.ts

@@ -85,7 +85,11 @@ describe("Compaction benchmark", () => {
     const counter = { calls: 0 };
     const provider = makeSummaryProvider(counter);
     const config = makeConfig();
-    const manager = new ContextWindowManager(provider, "system prompt", config);
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
 
     // 90 turns = 180 messages, well above 60% of 6000 = 3600 threshold
     const messages = makeLongMessages(90);
@@ -108,7 +112,11 @@ describe("Compaction benchmark", () => {
     const counter = { calls: 0 };
     const provider = makeSummaryProvider(counter);
     const config = makeConfig();
-    const manager = new ContextWindowManager(provider, "system prompt", config);
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
 
     // 3 turns = 6 messages, well below threshold
     const messages = makeLongMessages(3);
@@ -127,7 +135,11 @@ describe("Compaction benchmark", () => {
     const counter = { calls: 0 };
     const provider = makeSummaryProvider(counter);
     const config = makeConfig();
-    const manager = new ContextWindowManager(provider, "system prompt", config);
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
 
     const messages = makeLongMessages(90);
     const result = await manager.maybeCompact(messages);
@@ -143,7 +155,11 @@ describe("Compaction benchmark", () => {
     const counter = { calls: 0 };
     const provider = makeSummaryProvider(counter);
     const config = makeConfig();
-    const manager = new ContextWindowManager(provider, "system prompt", config);
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
 
     const messages = makeLongMessages(90);
     const result = await manager.maybeCompact(messages);
@@ -163,7 +179,11 @@ describe("Compaction benchmark", () => {
       maxInputTokens: 4000,
       targetInputTokens: 2000,
     };
-    const manager = new ContextWindowManager(provider, "system prompt", config);
+    const manager = new ContextWindowManager({
+      provider,
+      systemPrompt: "system prompt",
+      config,
+    });
 
     const messages = makeLongMessages(90);
     const estimated = estimatePromptTokens(messages, "system prompt", {

package/src/__tests__/computer-use-session-lifecycle.test.ts

@@ -28,7 +28,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { CuObservation, ServerMessage } from "../daemon/ipc-protocol.js";
+import type { CuObservation, ServerMessage } from "../daemon/message-protocol.js";
 import type { Provider, ProviderResponse } from "../providers/types.js";
 
 function createProvider(responses: ProviderResponse[]): {

package/src/__tests__/computer-use-session-working-dir.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
 
-import type { CuObservation } from "../daemon/ipc-protocol.js";
+import type { CuObservation } from "../daemon/message-protocol.js";
 import type { Provider } from "../providers/types.js";
 
 let capturedWorkingDir: string | undefined;
@@ -28,7 +28,7 @@ mock.module("../util/platform.js", () => ({
   ...realPlatform,
   getRootDir: () => "/tmp",
   getDataDir: () => "/tmp/data",
-  getIpcBlobDir: () => "/tmp/data/ipc-blobs",
+
   getSandboxRootDir: () => "/tmp/sandbox",
   getSandboxWorkingDir: () => "/tmp/workspace",
   getInterfacesDir: () => "/tmp/interfaces",
@@ -46,11 +46,7 @@ mock.module("../util/platform.js", () => ({
   getHistoryPath: () => "/tmp/data/history",
   getHooksDir: () => "/tmp/hooks",
   readSessionToken: () => null,
-  removeSocketFile: () => {},
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migratePath: () => {},
   isMacOS: () => false,
   isLinux: () => true,
   isWindows: () => false,

package/src/__tests__/computer-use-skill-lifecycle-cleanup.test.ts

@@ -26,7 +26,7 @@ mock.module("../config/loader.js", () => ({
 }));
 
 import { ComputerUseSession } from "../daemon/computer-use-session.js";
-import type { CuObservation } from "../daemon/ipc-protocol.js";
+import type { CuObservation } from "../daemon/message-protocol.js";
 import type { Provider, ProviderResponse } from "../providers/types.js";
 import {
   __resetRegistryForTesting,

package/src/__tests__/config-loader-backfill.test.ts

@@ -0,0 +1,310 @@
+import { randomBytes } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — declared before imports that depend on platform/logger
+// ---------------------------------------------------------------------------
+
+const TEST_DIR = join(
+  tmpdir(),
+  `vellum-backfill-test-${randomBytes(4).toString("hex")}`,
+);
+const WORKSPACE_DIR = join(TEST_DIR, "workspace");
+const CONFIG_PATH = join(WORKSPACE_DIR, "config.json");
+
+function ensureTestDir(): void {
+  const dirs = [
+    TEST_DIR,
+    WORKSPACE_DIR,
+    join(TEST_DIR, "data"),
+    join(TEST_DIR, "memory"),
+    join(TEST_DIR, "memory", "knowledge"),
+    join(TEST_DIR, "logs"),
+  ];
+  for (const dir of dirs) {
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+}
+
+function makeLoggerStub(): Record<string, unknown> {
+  const stub: Record<string, unknown> = {};
+  for (const m of [
+    "info",
+    "warn",
+    "error",
+    "debug",
+    "trace",
+    "fatal",
+    "silent",
+    "child",
+  ]) {
+    stub[m] = m === "child" ? () => makeLoggerStub() : () => {};
+  }
+  return stub;
+}
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () => makeLoggerStub(),
+}));
+
+mock.module("../util/platform.js", () => ({
+  getRootDir: () => TEST_DIR,
+  getWorkspaceDir: () => WORKSPACE_DIR,
+  getWorkspaceConfigPath: () => CONFIG_PATH,
+  getDataDir: () => join(TEST_DIR, "data"),
+  getLogPath: () => join(TEST_DIR, "logs", "vellum.log"),
+  ensureDataDir: () => ensureTestDir(),
+  isMacOS: () => false,
+  isLinux: () => false,
+  isWindows: () => false,
+}));
+
+// Restore all mocked modules after this file's tests complete to prevent
+// cross-test contamination when running grouped with other test files.
+afterAll(() => {
+  mock.restore();
+});
+
+import {
+  deepMergeMissing,
+  invalidateConfigCache,
+  loadConfig,
+} from "../config/loader.js";
+import { _setStorePath } from "../security/encrypted-store.js";
+import { _setBackend } from "../security/secure-keys.js";
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function writeConfig(obj: unknown): void {
+  writeFileSync(CONFIG_PATH, JSON.stringify(obj, null, 2) + "\n");
+}
+
+function readConfig(): Record<string, unknown> {
+  return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+}
+
+// ---------------------------------------------------------------------------
+// Tests: deepMergeMissing (unit)
+// ---------------------------------------------------------------------------
+
+describe("deepMergeMissing", () => {
+  test("adds missing top-level keys", () => {
+    const target: Record<string, unknown> = { a: 1 };
+    const defaults: Record<string, unknown> = { a: 99, b: 2 };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(true);
+    expect(target).toEqual({ a: 1, b: 2 });
+  });
+
+  test("does not overwrite existing values", () => {
+    const target: Record<string, unknown> = { a: 1, b: "user" };
+    const defaults: Record<string, unknown> = { a: 99, b: "default" };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(false);
+    expect(target).toEqual({ a: 1, b: "user" });
+  });
+
+  test("recursively fills nested objects", () => {
+    const target: Record<string, unknown> = {
+      nested: { existingKey: "keep" },
+    };
+    const defaults: Record<string, unknown> = {
+      nested: { existingKey: "default", newKey: 42 },
+    };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(true);
+    expect(target).toEqual({
+      nested: { existingKey: "keep", newKey: 42 },
+    });
+  });
+
+  test("returns false when no changes needed", () => {
+    const target: Record<string, unknown> = { a: 1, b: { c: 3 } };
+    const defaults: Record<string, unknown> = { a: 99, b: { c: 100 } };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(false);
+  });
+
+  test("does not merge arrays", () => {
+    const target: Record<string, unknown> = { items: [1, 2] };
+    const defaults: Record<string, unknown> = { items: [3, 4, 5] };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(false);
+    expect(target).toEqual({ items: [1, 2] });
+  });
+
+  test("adds entire missing nested section", () => {
+    const target: Record<string, unknown> = {};
+    const defaults: Record<string, unknown> = {
+      slack: { deliverAuthBypass: false },
+    };
+    const changed = deepMergeMissing(target, defaults);
+    expect(changed).toBe(true);
+    expect(target).toEqual({ slack: { deliverAuthBypass: false } });
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: startup backfill integration
+// ---------------------------------------------------------------------------
+
+describe("config loader backfill", () => {
+  beforeEach(() => {
+    ensureTestDir();
+    const resetPaths = [
+      CONFIG_PATH,
+      join(TEST_DIR, "keys.enc"),
+      join(TEST_DIR, "data"),
+      join(TEST_DIR, "memory"),
+    ];
+    for (const path of resetPaths) {
+      if (existsSync(path)) {
+        rmSync(path, { recursive: true, force: true });
+      }
+    }
+    ensureTestDir();
+    _setStorePath(join(TEST_DIR, "keys.enc"));
+    _setBackend("encrypted");
+    invalidateConfigCache();
+  });
+
+  afterEach(() => {
+    _setStorePath(null);
+    _setBackend(undefined);
+    invalidateConfigCache();
+  });
+
+  test("backfills missing schema keys into existing config.json", () => {
+    // Write a minimal config that is missing many sections
+    writeConfig({ provider: "anthropic", model: "claude-opus-4-6" });
+
+    loadConfig();
+
+    // Re-read the file from disk — it should have been backfilled
+    const raw = readConfig();
+    // New fields from this PR should be present
+    expect(raw.telegram).toBeDefined();
+    expect((raw.telegram as Record<string, unknown>).apiBaseUrl).toBe(
+      "https://api.telegram.org",
+    );
+    expect((raw.telegram as Record<string, unknown>).deliverAuthBypass).toBe(
+      false,
+    );
+    expect((raw.telegram as Record<string, unknown>).timeoutMs).toBe(15_000);
+    expect((raw.telegram as Record<string, unknown>).maxRetries).toBe(3);
+    expect((raw.telegram as Record<string, unknown>).initialBackoffMs).toBe(
+      1_000,
+    );
+
+    expect(raw.whatsapp).toBeDefined();
+    expect((raw.whatsapp as Record<string, unknown>).deliverAuthBypass).toBe(
+      false,
+    );
+    expect((raw.whatsapp as Record<string, unknown>).timeoutMs).toBe(15_000);
+    expect((raw.whatsapp as Record<string, unknown>).maxRetries).toBe(3);
+    expect((raw.whatsapp as Record<string, unknown>).initialBackoffMs).toBe(
+      1_000,
+    );
+
+    expect(raw.slack).toBeDefined();
+    expect((raw.slack as Record<string, unknown>).deliverAuthBypass).toBe(
+      false,
+    );
+  });
+
+  test("preserves existing user-defined values during backfill", () => {
+    writeConfig({
+      provider: "openai",
+      model: "gpt-4",
+      telegram: { botUsername: "mybot", timeoutMs: 30_000 },
+      whatsapp: { phoneNumber: "+1234567890" },
+    });
+
+    loadConfig();
+
+    const raw = readConfig();
+    // User values preserved
+    expect(raw.provider).toBe("openai");
+    expect(raw.model).toBe("gpt-4");
+    expect((raw.telegram as Record<string, unknown>).botUsername).toBe("mybot");
+    expect((raw.telegram as Record<string, unknown>).timeoutMs).toBe(30_000);
+    expect((raw.whatsapp as Record<string, unknown>).phoneNumber).toBe(
+      "+1234567890",
+    );
+
+    // Missing fields backfilled
+    expect((raw.telegram as Record<string, unknown>).apiBaseUrl).toBe(
+      "https://api.telegram.org",
+    );
+    expect((raw.telegram as Record<string, unknown>).deliverAuthBypass).toBe(
+      false,
+    );
+    expect((raw.whatsapp as Record<string, unknown>).deliverAuthBypass).toBe(
+      false,
+    );
+  });
+
+  test("does not rewrite config.json when no effective change exists", () => {
+    // First load: creates config from scratch with all defaults
+    loadConfig();
+    invalidateConfigCache();
+
+    // Read file and record its content
+    const contentBefore = readFileSync(CONFIG_PATH, "utf-8");
+
+    // Second load: file already has all keys — no write expected
+    loadConfig();
+
+    const contentAfter = readFileSync(CONFIG_PATH, "utf-8");
+    expect(contentAfter).toBe(contentBefore);
+  });
+
+  test("does not write apiKeys or dataDir during backfill", () => {
+    writeConfig({ provider: "anthropic" });
+
+    loadConfig();
+
+    const raw = readConfig();
+    expect(raw.apiKeys).toBeUndefined();
+    expect(raw.dataDir).toBeUndefined();
+  });
+
+  test("backfills new nested fields into existing sections", () => {
+    // Config with only the old telegram.botUsername field
+    writeConfig({
+      telegram: { botUsername: "oldbot" },
+    });
+
+    loadConfig();
+
+    const raw = readConfig();
+    const telegram = raw.telegram as Record<string, unknown>;
+    // Old field preserved
+    expect(telegram.botUsername).toBe("oldbot");
+    // New fields backfilled
+    expect(telegram.apiBaseUrl).toBe("https://api.telegram.org");
+    expect(telegram.deliverAuthBypass).toBe(false);
+    expect(telegram.timeoutMs).toBe(15_000);
+    expect(telegram.maxRetries).toBe(3);
+    expect(telegram.initialBackoffMs).toBe(1_000);
+  });
+});

package/src/__tests__/config-watcher.test.ts

@@ -39,7 +39,7 @@ mock.module("../util/platform.js", () => ({
   getLogPath: () => join(WORKSPACE_DIR, "data", "logs", "vellum.log"),
   getHistoryPath: () => join(WORKSPACE_DIR, "data", "history"),
   getHooksDir: () => join(WORKSPACE_DIR, "hooks"),
-  getIpcBlobDir: () => join(WORKSPACE_DIR, "data", "ipc-blobs"),
+
   getSandboxRootDir: () => join(WORKSPACE_DIR, "data", "sandbox"),
   getSandboxWorkingDir: () => WORKSPACE_DIR,
   getInterfacesDir: () => join(WORKSPACE_DIR, "data", "interfaces"),
@@ -48,10 +48,6 @@ mock.module("../util/platform.js", () => ({
   isWindows: () => process.platform === "win32",
   getPlatformName: () => process.platform,
   getClipboardCommand: () => null,
-  removeSocketFile: () => {},
-  migratePath: () => {},
-  migrateToWorkspaceLayout: () => {},
-  migrateToDataLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({

package/src/__tests__/confirmation-request-guardian-bridge.test.ts

@@ -25,8 +25,6 @@ mock.module("../util/platform.js", () => ({
   getDbPath: () => join(testDir, "test.db"),
   getLogPath: () => join(testDir, "test.log"),
   ensureDataDir: () => {},
-  migrateToDataLayout: () => {},
-  migrateToWorkspaceLayout: () => {},
 }));
 
 mock.module("../util/logger.js", () => ({
@@ -74,7 +72,7 @@ mock.module("../notifications/emit-signal.js", () => ({
 }));
 
 // Mock channel guardian service — provide a guardian binding for 'self' + 'telegram'
-mock.module("../runtime/channel-guardian-service.js", () => ({
+mock.module("../runtime/channel-verification-service.js", () => ({
   getGuardianBinding: (assistantId: string, channel: string) => {
     if (assistantId === "self" && channel === "telegram") {
       return {
@@ -253,9 +251,9 @@ describe("bridgeConfirmationRequestToGuardian", () => {
   });
 
   test("skips when no guardian binding exists for channel", () => {
-    const canonicalRequest = makeCanonicalRequest({ sourceChannel: "sms" });
+    const canonicalRequest = makeCanonicalRequest({ sourceChannel: "phone" });
     const trustContext = makeTrustedContactContext({
-      sourceChannel: "sms",
+      sourceChannel: "phone",
     });
 
     const result = bridgeConfirmationRequestToGuardian({