@vellumai/assistant 0.7.3 → 0.8.1

package/src/__tests__/conversation-process-callsite.test.ts

@@ -12,14 +12,8 @@
  */
 import { describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 // Use an object wrapper so TypeScript doesn't narrow the captured type to
 // `undefined` based on the initial assignment in the test setup.
 const captured: {
@@ -46,9 +40,28 @@ mock.module("../memory/guardian-action-store.js", () => ({
   resolveGuardianActionRequest: () => {},
 }));
 
+const mockProviderStub = { name: "mock-provider" };
 mock.module("../providers/registry.js", () => ({
-  getProvider: () => ({ name: "mock-provider" }),
+  getProvider: () => mockProviderStub,
   initializeProviders: () => {},
+  listProviders: () => ["anthropic", "openai", "gemini"],
+  resolveProviderFromConnection: async () => mockProviderStub,
+}));
+
+// Connection-aware resolver path: satisfy
+// `tryResolveProviderForConnectionName` lookups so resolveDefaultProvider
+// returns a usable provider for the inline `anthropic-conn` fixture.
+mock.module("../providers/inference/connections.js", () => ({
+  getConnection: (_db: unknown, name: string) => ({
+    id: 1,
+    name,
+    provider: "anthropic",
+    auth_strategy: "user_managed_credential",
+    credential_alias: null,
+    metadata_json: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+  }),
 }));
 
 mock.module("../config/loader.js", () => ({
@@ -57,6 +70,7 @@ mock.module("../config/loader.js", () => ({
     llm: {
       default: {
         provider: "anthropic",
+        provider_connection: "anthropic-conn",
         model: "claude-opus-4-6",
         maxTokens: 4096,
         effort: "max" as const,
@@ -83,6 +97,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-provider-retry-repair.test.ts

@@ -1,17 +1,11 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
 import type { AgentEvent } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { UserMessageAttachment } from "../daemon/message-protocol.js";
 import { resetPluginRegistryAndRegisterDefaults } from "../plugins/defaults/index.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 import { ProviderError } from "../util/errors.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 mock.module("../util/logger.js", () => ({
   getLogger: () =>
     new Proxy({} as Record<string, unknown>, { get: () => () => {} }),
@@ -63,6 +57,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     services: {
       inference: {
         mode: "your-own",

package/src/__tests__/conversation-runtime-assembly.test.ts

@@ -1,11 +1,20 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
-
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
+// This test exercises v1 PKB injection. `config.memory.v2.enabled` (default
+// `true`) makes the PKB injector go silent — force it off here so the v1
+// injection chain assertions stay meaningful.
+const realLoaderForAssemblyTest = await import("../config/loader.js");
+const realGetConfigForAssemblyTest = realLoaderForAssemblyTest.getConfig;
+mock.module("../config/loader.js", () => ({
+  ...realLoaderForAssemblyTest,
+  getConfig: () => {
+    const real = realGetConfigForAssemblyTest();
+    return {
+      ...real,
+      memory: { ...real.memory, v2: { ...real.memory.v2, enabled: false } },
+    };
+  },
+}));
 
 // PKB search is mocked so the reminder-hints tests can assert behavior
 // without standing up Qdrant. The mock returns whatever is staged in
@@ -1870,7 +1879,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
     },
   ];
 
-  const FLAT_REMINDER = buildPkbReminder([]);
+  const FLAT_REMINDER = buildPkbReminder([], false);
 
   // Use a platform-agnostic absolute workspace root so the tests work on
   // macOS and Linux runners alike. `pkbRoot` sits under `pkbWorkingDir` to
@@ -2126,7 +2135,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
       role: "user",
       content: [
         { type: "text", text: "hello" },
-        { type: "text", text: buildPkbReminder([]) },
+        { type: "text", text: buildPkbReminder([], false) },
       ],
     };
     const hintedMessage: Message = {
@@ -2135,7 +2144,7 @@ describe("applyRuntimeInjections — PKB relevance hints", () => {
         { type: "text", text: "hello" },
         {
           type: "text",
-          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"]),
+          text: buildPkbReminder(["topics/alpha.md", "topics/beta.md"], false),
         },
       ],
     };
@@ -4751,7 +4760,7 @@ describe("applyRuntimeInjections blocks.pkbSystemReminder", () => {
       mode: "full",
     });
 
-    const expected = buildPkbReminder([]);
+    const expected = buildPkbReminder([], false);
     expect(blocks.pkbSystemReminder).toBe(expected);
   });
 

package/src/__tests__/conversation-slash-commands.test.ts

@@ -1,10 +1,16 @@
-import { describe, expect, test } from "bun:test";
+import { writeFileSync } from "node:fs";
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 
+import {
+  invalidateConfigCache,
+  loadRawConfig,
+} from "../config/loader.js";
 import {
   classifySlash,
   resolveSlash,
   type SlashContext,
 } from "../daemon/conversation-slash.js";
+import { getWorkspaceConfigPath } from "../util/platform.js";
 
 function makeSlashContext(overrides: Partial<SlashContext> = {}): SlashContext {
   return {
@@ -37,12 +43,12 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
       "/fork — Fork the current conversation into a new branch",
     ]);
-    expect(lines).not.toContain("/model — Switch the active model");
   });
 
   test("renders iOS command help with /fork", async () => {
@@ -53,6 +59,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -68,6 +75,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
       "/btw — Ask a side question while the assistant is working",
@@ -80,6 +88,7 @@ describe("resolveSlash /commands interface-aware help", () => {
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
       "/context — Show conversation context usage",
+      "/model — List or switch inference profile",
       "/models — List all available models",
       "/status — Show conversation status and context usage",
     ]);
@@ -90,6 +99,7 @@ describe("resolveSlash /commands interface-aware help", () => {
     expect(lines).toEqual([
       "/commands — List all available commands",
       "/compact — Force context compaction immediately",
+      "/model — List or switch inference profile",
       "/models — List all available models",
     ]);
   });
@@ -128,6 +138,55 @@ describe("resolveSlash command contract", () => {
   });
 });
 
+describe("resolveSlash /compact target override", () => {
+  test("plain /compact returns no override", async () => {
+    const result = await resolveSlash("/compact");
+    expect(result).toEqual({ kind: "compact" });
+  });
+
+  test("/compact <integer> sets explicit token target", async () => {
+    const result = await resolveSlash("/compact 30000");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 30000,
+    });
+  });
+
+  test("/compact <n>k expands to thousands", async () => {
+    const result = await resolveSlash("/compact 30k");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 30_000,
+    });
+  });
+
+  test("/compact <n>m expands to millions", async () => {
+    const result = await resolveSlash("/compact 1.5M");
+    expect(result).toEqual({
+      kind: "compact",
+      targetInputTokensOverride: 1_500_000,
+    });
+  });
+
+  test("/compact rejects malformed args with usage hint", async () => {
+    const result = await resolveSlash("/compact bogus");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown");
+    expect(result.message).toContain("`bogus`");
+    expect(result.message).toContain("/compact");
+  });
+
+  test("/compact rejects zero", async () => {
+    const result = await resolveSlash("/compact 0");
+    expect(result.kind).toBe("unknown");
+  });
+
+  test("/compact rejects negative numbers", async () => {
+    const result = await resolveSlash("/compact -50");
+    expect(result.kind).toBe("unknown");
+  });
+});
+
 describe("classifySlash is a pure classifier matching resolveSlash kinds", () => {
   // Lookahead in `buildPassthroughBatch` must not run `resolveSlash`'s side
   // effects. The pure classifier is synchronous, takes no side-effecting
@@ -141,11 +200,16 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     { input: "/status", kind: "unknown" },
     { input: "/commands", kind: "unknown" },
     { input: "/compact", kind: "compact" },
+    { input: "/compact 30000", kind: "compact" },
+    { input: "/compact 30k", kind: "compact" },
+    { input: "/compact 1.5M", kind: "compact" },
+    { input: "/compact bogus", kind: "unknown" },
     { input: "/model", kind: "unknown" },
     { input: "/model foo", kind: "unknown" },
     { input: "/opus", kind: "unknown" },
     { input: "hello", kind: "passthrough" },
     { input: "  /compact  ", kind: "compact" },
+    { input: "  /compact 50k  ", kind: "compact" },
     { input: "/models foo", kind: "passthrough" },
   ];
 
@@ -160,3 +224,131 @@ describe("classifySlash is a pure classifier matching resolveSlash kinds", () =>
     });
   }
 });
+
+// ── /model — inference profile switcher ────────────────────────────
+
+function writeFixtureConfig(config: Record<string, unknown>): void {
+  writeFileSync(getWorkspaceConfigPath(), JSON.stringify(config), "utf-8");
+  invalidateConfigCache();
+}
+
+describe("resolveSlash /model — inference profile switcher", () => {
+  beforeEach(() => {
+    writeFixtureConfig({
+      llm: {
+        profiles: {
+          balanced: {
+            label: "Balanced",
+            description: "Default mix of speed and quality",
+          },
+          "cost-optimized": {
+            label: "Cost-optimized",
+            description: "Cheaper models, slower",
+          },
+          "short-context": {
+            label: "Short context",
+            status: "disabled",
+          },
+        },
+        profileOrder: ["balanced", "cost-optimized", "short-context"],
+        activeProfile: "balanced",
+      },
+    });
+  });
+
+  afterEach(() => {
+    invalidateConfigCache();
+  });
+
+  test("`/model` lists profiles with current marker, status, and description", async () => {
+    const result = await resolveSlash("/model");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toContain("Inference profiles:");
+    expect(result.message).toContain(
+      "`balanced` (Balanced) **[current]** — Default mix of speed and quality",
+    );
+    expect(result.message).toContain(
+      "`cost-optimized` (Cost-optimized) — Cheaper models, slower",
+    );
+    expect(result.message).toContain(
+      "`short-context` (Short context) *(disabled)*",
+    );
+    expect(result.message).toContain("Switch with `/model <name>`.");
+  });
+
+  test("`/model <name>` switches the active profile and writes config to disk", async () => {
+    const result = await resolveSlash("/model cost-optimized");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Switched to profile `cost-optimized` (Cost-optimized).",
+    );
+
+    const persisted = loadRawConfig() as {
+      llm?: { activeProfile?: string };
+    };
+    expect(persisted.llm?.activeProfile).toBe("cost-optimized");
+  });
+
+  test("`/model <unknown>` returns an error with available profile names", async () => {
+    const result = await resolveSlash("/model gemini");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toContain("Profile `gemini` not found.");
+    expect(result.message).toContain("`balanced`");
+    expect(result.message).toContain("`cost-optimized`");
+  });
+
+  test("`/model <disabled>` refuses to switch and points at Settings", async () => {
+    const result = await resolveSlash("/model short-context");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Profile `short-context` is disabled. Enable it in **Settings → Models & Services** first.",
+    );
+    // Disk should NOT have been written.
+    const persisted = loadRawConfig() as {
+      llm?: { activeProfile?: string };
+    };
+    expect(persisted.llm?.activeProfile).toBe("balanced");
+  });
+
+  test("`/model <current>` is a no-op with a friendly message", async () => {
+    const result = await resolveSlash("/model balanced");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Already using profile `balanced` (Balanced).",
+    );
+  });
+
+  test("`/model` with no profiles defined points at Settings", async () => {
+    writeFixtureConfig({
+      llm: { profiles: {}, profileOrder: [] },
+    });
+    const result = await resolveSlash("/model");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "No inference profiles are defined. Use **Settings → Models & Services** to create one.",
+    );
+  });
+
+  test("`/model <name>` trims surrounding whitespace from the argument", async () => {
+    const result = await resolveSlash("/model   cost-optimized  ");
+    expect(result.kind).toBe("unknown");
+    if (result.kind !== "unknown") throw new Error("expected unknown kind");
+    expect(result.message).toBe(
+      "Switched to profile `cost-optimized` (Cost-optimized).",
+    );
+  });
+
+  test("`/models` (plural) is not parsed as a /model invocation", async () => {
+    // /models is a separate command handled elsewhere; this test guards the
+    // boundary so we don't accidentally swallow it as a typo'd /model.
+    expect(classifySlash("/models")).toBe("unknown");
+    // /models foo is passthrough (existing behavior).
+    expect(classifySlash("/models foo")).toBe("passthrough");
+  });
+});

package/src/__tests__/conversation-slash-unknown.test.ts

@@ -5,15 +5,9 @@ import type {
   CheckpointDecision,
   CheckpointInfo,
 } from "../agent/loop.js";
-import { _setOverridesForTesting } from "../config/assistant-feature-flags.js";
 import type { ServerMessage } from "../daemon/message-protocol.js";
 import type { Message, ProviderResponse } from "../providers/types.js";
 
-// This test exercises v1 conversation routing. The `memory-v2-enabled` flag
-// (registry default `true`) flips memory routing to v2 — disable it here so
-// the v1 paths under test stay active.
-_setOverridesForTesting({ "memory-v2-enabled": false });
-
 // ---------------------------------------------------------------------------
 // Mocks — must precede the Conversation import so Bun applies them at load time.
 // ---------------------------------------------------------------------------
@@ -66,6 +60,7 @@ mock.module("../config/loader.js", () => ({
       pricingOverrides: [],
     },
     rateLimit: { maxRequestsPerMinute: 0 },
+    memory: { v2: { enabled: false } },
     daemon: {
       startupSocketWaitMs: 5000,
       stopTimeoutMs: 5000,

package/src/__tests__/conversation-surfaces-action-delivery.test.ts

@@ -1,13 +1,19 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  createSurfaceMutex,
-  handleSurfaceAction,
-  type SurfaceConversationContext,
-  surfaceProxyResolver,
-} from "../daemon/conversation-surfaces.js";
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+let broadcastedMessages: ServerMessage[] = [];
+const realEventHub = await import("../runtime/assistant-event-hub.js");
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  ...realEventHub,
+  broadcastMessage: (msg: ServerMessage) => broadcastedMessages.push(msg),
+}));
+
+const { createSurfaceMutex, handleSurfaceAction, surfaceProxyResolver } =
+  await import("../daemon/conversation-surfaces.js");
+
+import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
 import type {
-  ServerMessage,
   SurfaceData,
   SurfaceType,
   UiSurfaceShow,
@@ -81,6 +87,10 @@ function makeContext(sent: ServerMessage[] = []): SurfaceConversationContext & {
 }
 
 describe("surface action delivery to assistant", () => {
+  beforeEach(() => {
+    broadcastedMessages = [];
+  });
+
   test("table action button click triggers processMessage with action content", async () => {
     const sent: ServerMessage[] = [];
     const ctx = makeContext(sent);
@@ -199,4 +209,155 @@ describe("surface action delivery to assistant", () => {
       "[User action on app:",
     );
   });
+
+  test("confirmation surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "confirmation",
+      title: "Delete files?",
+      data: {
+        message: "This will permanently delete 3 files.",
+        confirmLabel: "Delete",
+        cancelLabel: "Keep",
+      },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "confirm", {});
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+    expect(completeMsg?.summary).toContain("Delete");
+  });
+
+  test("file_upload surface broadcasts ui_surface_complete on action", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    const showResult = await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload documents",
+      data: { accept: ".pdf,.docx", maxFiles: 5 },
+    });
+
+    expect(showResult.isError).toBe(false);
+    expect(showResult.yieldToUser).toBe(true);
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+    expect(ctx.pendingSurfaceActions.has(surfaceId)).toBe(true);
+
+    await handleSurfaceAction(ctx, surfaceId, "submit", {
+      files: [
+        {
+          filename: "doc.pdf",
+          mimeType: "application/pdf",
+          data: "base64encodedcontent",
+        },
+      ],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+    expect(completeMsg?.conversationId).toBe("conv-1");
+  });
+
+  test("file_upload completion event does not include base64 file blobs", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "file_upload",
+      title: "Upload",
+      data: { accept: "*" },
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    const largeBase64 = "A".repeat(10_000);
+    await handleSurfaceAction(ctx, surfaceId, "submit", {
+      files: [
+        {
+          filename: "big.pdf",
+          mimeType: "application/pdf",
+          data: largeBase64,
+        },
+      ],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+          "ui_surface_complete" &&
+        (m as unknown as Record<string, unknown>).surfaceId === surfaceId,
+    ) as unknown as Record<string, unknown> | undefined;
+    expect(completeMsg).toBeDefined();
+
+    const submittedData = completeMsg?.submittedData as
+      | Record<string, unknown>
+      | undefined;
+    // The files array with base64 blobs should be stripped from the
+    // completion event — only the sanitized payload (without files) is sent.
+    expect(submittedData?.files).toBeUndefined();
+    // The raw base64 content should not appear anywhere in the event
+    expect(JSON.stringify(completeMsg)).not.toContain(largeBase64);
+  });
+
+  test("table surface does NOT broadcast ui_surface_complete (not one-shot)", async () => {
+    const sent: ServerMessage[] = [];
+    const ctx = makeContext(sent);
+
+    await surfaceProxyResolver(ctx, "ui_show", {
+      surface_type: "table",
+      title: "Items",
+      data: {
+        columns: [{ id: "name", label: "Name" }],
+        rows: [{ id: "r1", cells: { name: "Item 1" } }],
+      },
+      actions: [{ id: "select", label: "Select" }],
+    });
+
+    const showMessage = sent.find(
+      (msg): msg is UiSurfaceShow => msg.type === "ui_surface_show",
+    ) as UiSurfaceShow;
+    const surfaceId = showMessage.surfaceId;
+
+    broadcastedMessages = [];
+    await handleSurfaceAction(ctx, surfaceId, "select", {
+      selectedIds: ["r1"],
+    });
+
+    const completeMsg = broadcastedMessages.find(
+      (m) =>
+        (m as unknown as Record<string, unknown>).type ===
+        "ui_surface_complete",
+    );
+    expect(completeMsg).toBeUndefined();
+  });
 });