@vellumai/assistant 0.12.1 → 0.12.2-dev.202609162214.308bda0

package/scripts/smoke-desktop-window-theme.ts

@@ -0,0 +1,186 @@
+import assert from "node:assert/strict";
+import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { writeDesktopWindowTheme } from "../src/desktop/desktop-window-theme.js";
+
+if (process.platform !== "linux") {
+  throw new Error(
+    "Run in a disposable Linux environment with Xvfb, Openbox, xterm, xdotool, xwininfo and xmllint installed",
+  );
+}
+
+const directory = await mkdtemp(join(tmpdir(), "window-theme-smoke-"));
+const env = { ...process.env, DISPLAY: ":97" };
+const children: ReturnType<typeof Bun.spawn>[] = [];
+const start = (cmd: string[]) => {
+  const child = Bun.spawn(cmd, {
+    env,
+    stdout: "ignore",
+    stderr: "inherit",
+    windowsHide: true,
+  });
+  children.push(child);
+  return child;
+};
+const run = (...cmd: string[]) => {
+  const result = Bun.spawnSync(cmd, {
+    env,
+
+    windowsHide: true,
+  });
+  assert.equal(result.exitCode, 0, result.stderr.toString());
+  return result.stdout.toString();
+};
+const waitFor = async (predicate: () => boolean) => {
+  for (let attempt = 0; attempt < 100; attempt++) {
+    try {
+      if (predicate()) {
+        return;
+      }
+    } catch {}
+    await Bun.sleep(50);
+  }
+  throw new Error("Window theme smoke condition timed out");
+};
+const pointer = async (...args: string[]) => {
+  run("xdotool", ...args);
+  await Bun.sleep(200);
+};
+const geometry = () => {
+  const info = run("xwininfo", "-name", "Theme smoke");
+  return [
+    "Absolute upper-left X",
+    "Absolute upper-left Y",
+    "Width",
+    "Height",
+  ].map((label) =>
+    Number(new RegExp(`${label}:\\s+(-?\\d+)`).exec(info)?.[1]),
+  ) as [number, number, number, number];
+};
+const state = () => run("xprop", "-name", "Theme smoke", "_NET_WM_STATE");
+const button = async (offset: number) => {
+  const [x, y, width] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - offset),
+    String(y - 16),
+    "click",
+    "1",
+  );
+};
+
+try {
+  const home = join(directory, "home");
+  const sourceDir = join(home, ".config", "openbox");
+  await mkdir(sourceDir, { recursive: true });
+  const original = await readFile("/etc/xdg/openbox/rc.xml", "utf8");
+  const mouse = original.match(/<mouse>[^]*?<\/mouse>/)![0];
+  const keyboard = original.match(/<keyboard>[^]*?<\/keyboard>/)![0];
+  const source = original
+    .replace(
+      mouse,
+      `<xi:include href="bindings.xml" xpointer="xpointer(/*/*)"/>`,
+    )
+    .replace(keyboard, "");
+  const sourcePath = join(sourceDir, "rc.xml");
+  await writeFile(sourcePath, source);
+  await writeFile(
+    join(sourceDir, "bindings.xml"),
+    `<bindings xmlns="http://openbox.org/3.4/rc">${mouse}${keyboard}</bindings>`,
+  );
+  const configDir = join(directory, "managed & theme");
+  const config = writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  const expanded = run("xmllint", "--xinclude", config);
+  assert(
+    expanded.includes("NextWindow") && expanded.includes("Move"),
+    "Relative includes must retain the actual keyboard and mouse bindings",
+  );
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  writeDesktopWindowTheme(configDir, home, "#bc7799");
+  writeDesktopWindowTheme(configDir, home, "#53b7aa");
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const blocked = join(directory, "blocked");
+  await writeFile(blocked, "not a directory");
+  assert.throws(() => writeDesktopWindowTheme(blocked, home));
+  assert.equal(await readFile(sourcePath, "utf8"), source);
+  const customBase = source.replace(
+    "<openbox_config",
+    '<openbox_config xml:base="./custom/"',
+  );
+  await writeFile(sourcePath, customBase);
+  assert.throws(() => writeDesktopWindowTheme(configDir, home));
+  assert.equal(await readFile(sourcePath, "utf8"), customBase);
+  await writeFile(sourcePath, source);
+
+  start(["Xvfb", ":97", "-screen", "0", "1100x700x24"]);
+  await waitFor(
+    () => run("xdotool", "getdisplaygeometry").trim() === "1100 700",
+  );
+  start(["openbox", "--config-file", config]);
+  await waitFor(() =>
+    run("xprop", "-root", "_OB_THEME").includes("window-theme"),
+  );
+  start([
+    "xterm",
+    "-title",
+    "Theme smoke",
+    "-geometry",
+    "48x12+450+250",
+    "-e",
+    "sleep",
+    "60",
+  ]);
+  await waitFor(
+    () => run("xdotool", "search", "--name", "^Theme smoke$").trim().length > 0,
+  );
+  await Bun.sleep(300);
+  const id = run("xdotool", "search", "--name", "^Theme smoke$").trim();
+  await button(39);
+  assert(
+    state().includes("MAXIMIZED_HORZ") && state().includes("MAXIMIZED_VERT"),
+  );
+  await button(39);
+  assert(!state().includes("MAXIMIZED"));
+  await button(62);
+  assert(state().includes("HIDDEN"));
+  await pointer("windowactivate", id);
+  assert(!state().includes("HIDDEN"));
+  let [x, y, width, height] = geometry();
+  await pointer("mousemove", String(x + 100), String(y - 16), "mousedown", "1");
+  await pointer("mousemove", String(x + 90), String(y - 26));
+  await pointer("mousemove", String(x + 45), String(y - 65));
+  await pointer("mouseup", "1");
+  const [movedX, movedY] = geometry();
+  assert(Math.abs(movedX - x) >= 30 && Math.abs(movedY - y) >= 30);
+  [x, y, width, height] = geometry();
+  await pointer(
+    "mousemove",
+    String(x + width - 2),
+    String(y + height + 2),
+    "mousedown",
+    "1",
+  );
+  await pointer("mousemove", String(x + width + 10), String(y + height + 10));
+  await pointer("mousemove", String(x + width + 60), String(y + height + 40));
+  await pointer("mouseup", "1");
+  const [, , resizedWidth, resizedHeight] = geometry();
+  assert(resizedWidth > width && resizedHeight > height);
+  await pointer("key", "alt+F4");
+  await waitFor(
+    () =>
+      !run("xprop", "-root", "_NET_CLIENT_LIST").includes(
+        `0x${Number(id).toString(16)}`,
+      ),
+  );
+  console.log(
+    "PASS: relative includes, preserved source, repeated theme updates, maximize/restore, minimize/activation, dragging, resizing, and keyboard close",
+  );
+} finally {
+  for (const child of children.reverse()) {
+    child.kill();
+  }
+  await Promise.all(children.map((child) => child.exited));
+  await rm(directory, { recursive: true, force: true });
+}

package/scripts/sync-llm-catalog.ts

@@ -86,6 +86,9 @@ function projectModel(model: CatalogModel): Record<string, unknown> {
   if (model.supportsToolUse !== undefined) {
     projected.supportsToolUse = model.supportsToolUse;
   }
+  if (model.supportsText !== undefined) {
+    projected.supportsText = model.supportsText;
+  }
   if (model.pricing !== undefined) {
     projected.pricing = model.pricing;
   }

package/scripts/test.ts

@@ -62,26 +62,28 @@ const EXPERIMENTAL_FILES = new Set([
 const KNOWN_BROKEN_FILES = new Set<string>([]);
 
 // ---------------------------------------------------------------------------
-// Feature-flag registry sync
+// Bundled catalog sync
 // ---------------------------------------------------------------------------
 
-// Ensure the bundled feature-flag-registry.json exists before running tests.
-// The canonical copy lives at meta/feature-flags/feature-flag-registry.json and
-// is synced into assistant/src/ and gateway/src/. CI runs this as a dedicated
-// step; locally postinstall handles it — but when node_modules is symlinked
-// (e.g. worktrees) postinstall never fires, so the bundled copy can be missing
-// and feature-flag-registry-bundled.test.ts fails. Running the sync here is
-// idempotent and cheap (two file copies).
-function syncFeatureFlagRegistry(): void {
+// Ensure generated catalog inputs exist before tests. Locally, postinstall may
+// not run in worktrees that share node_modules, so the static JSON imports can
+// otherwise be missing.
+function syncBundledCatalog(): void {
   const syncScript = join("..", "meta", "sync-bundled-copies.ts");
   if (!existsSync(syncScript)) {
     return;
   }
-  Bun.spawnSync(["bun", "run", "meta/sync-bundled-copies.ts"], {
-    cwd: join(process.cwd(), ".."),
+  const result = Bun.spawnSync(["bun", "run", "sync:bundled-catalog"], {
+    cwd: process.cwd(),
     stdout: "ignore",
-    stderr: "ignore",
+    stderr: "pipe",
+    windowsHide: true,
   });
+  if (result.exitCode !== 0) {
+    throw new Error(
+      `Failed to generate bundled catalog inputs: ${result.stderr.toString()}`,
+    );
+  }
 }
 
 // ---------------------------------------------------------------------------
@@ -514,7 +516,7 @@ async function buildMigratedFixture(outWorkspaceDir: string): Promise<void> {
 // ---------------------------------------------------------------------------
 
 async function main(): Promise<void> {
-  syncFeatureFlagRegistry();
+  syncBundledCatalog();
 
   let testFiles = collectTestFiles();
   if (testFiles.length === 0) {

package/scripts/voice-ttft-spike.ts

@@ -15,7 +15,7 @@
  *   full-quality  quality-optimized, full prompt + tools (pre-flag brain)
  *
  * Run with the daemon's environment so the managed connection resolves:
- *   VELLUM_WORKSPACE_DIR=<daemon workspace> CES_LOCAL_SOCKET=<socket> \
+ *   VELLUM_WORKSPACE_DIR=<daemon workspace> \
  *     bun run scripts/voice-ttft-spike.ts [--trials 3] [--variants a,b]
  *
  * Outside the daemon env, credentials fall back to the encrypted file
@@ -217,7 +217,7 @@ async function main(): Promise<void> {
     if (!provider) {
       console.error(
         `${spec.name}: no provider resolved (managed credentials missing? ` +
-          `run with the daemon's VELLUM_WORKSPACE_DIR + CES_LOCAL_SOCKET)`,
+          `run with the daemon's VELLUM_WORKSPACE_DIR)`,
       );
       continue;
     }

package/src/__tests__/agent-loop.test.ts

@@ -1977,6 +1977,130 @@ describe("AgentLoop", () => {
     expect(calls[0].tools).not.toEqual(dummyTools);
   });
 
+  test("onToolsSent observes the exact tool array of every provider call", async () => {
+    const perCall: ToolDefinition[][] = [
+      [
+        {
+          name: "first",
+          description: "First",
+          input_schema: { type: "object" },
+        },
+      ],
+      [
+        {
+          name: "second",
+          description: "Second",
+          input_schema: { type: "object" },
+        },
+      ],
+    ];
+    let resolveCount = 0;
+    const sent: ToolDefinition[][] = [];
+
+    const { provider, calls } = createMockProvider([
+      toolUseResponse("t1", "first", {}),
+      textResponse("Done"),
+    ]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      toolExecutor: async () => ({ content: "result", isError: false }),
+      resolveTools: () => perCall[resolveCount++]!,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // One observation per provider call, each the array that call sent.
+    expect(sent).toHaveLength(2);
+    expect(calls[0].tools).toEqual(sent[0]);
+    expect(calls[1].tools).toEqual(sent[1]);
+    expect(sent.map((tools) => tools.map((t) => t.name))).toEqual([
+      ["first"],
+      ["second"],
+    ]);
+  });
+
+  test("onToolsSent sees the provider-native web_search tool the loop appends", async () => {
+    const dynamicTools: ToolDefinition[] = [
+      {
+        name: "dynamic_tool",
+        description: "Dynamic",
+        input_schema: { type: "object" },
+      },
+    ];
+    const sent: ToolDefinition[][] = [];
+
+    const { provider, calls } = createMockProvider([textResponse("Hi")]);
+    Object.assign(provider, { supportsNativeWebSearch: true });
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      config: { enableNativeWebSearch: true },
+      resolveTools: () => dynamicTools,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+    await loop.run({
+      requestId: "test-request",
+      messages: [userMessage],
+      onEvent: () => {},
+      trust: { sourceChannel: "vellum", trustClass: "unknown" },
+    });
+
+    // The resolver never saw web_search; the observer sees the wire array.
+    expect(sent).toHaveLength(1);
+    expect(sent[0]!.map((t) => t.name)).toEqual(["dynamic_tool", "web_search"]);
+    expect(calls[0].tools).toEqual(sent[0]);
+  });
+
+  test("onToolsSent does not fire for a call cancelled before the request leaves", async () => {
+    // A pre-model-call hook runs after tool resolution and before the send,
+    // so aborting there is a call whose tools are resolved but never sent.
+    const controller = new AbortController();
+    registerPlugin({
+      manifest: { name: "abort-before-send", version: "0.0.1" },
+      hooks: {
+        "pre-model-call": async (ctx) => {
+          controller.abort();
+          return ctx;
+        },
+      },
+    });
+    const sent: ToolDefinition[][] = [];
+    const { provider } = createMockProvider([textResponse("never")]);
+    const loop = new AgentLoop({
+      provider: provider,
+      systemPrompt: "system",
+      conversationId: "test-conversation",
+      resolveTools: () => dummyTools,
+      onToolsSent: (tools) => {
+        sent.push(tools);
+      },
+    });
+
+    await loop
+      .run({
+        requestId: "test-request",
+        messages: [userMessage],
+        onEvent: () => {},
+        trust: { sourceChannel: "vellum", trustClass: "unknown" },
+        signal: controller.signal,
+      })
+      .catch(() => {});
+
+    expect(sent).toEqual([]);
+  });
+
   // 28. Tool list can change between turns
   test("resolveTools can return different tools on each turn", async () => {
     const toolsPerTurn: ToolDefinition[][] = [

package/src/__tests__/always-loaded-tools-guard.test.ts

@@ -26,7 +26,7 @@ afterAll(() => {
 });
 
 describe("always-loaded tool count", () => {
-  test("should be exactly 11 with recall occupying the existing slot", async () => {
+  test("should be exactly 19 with recall occupying the existing slot", async () => {
     await initializeTools();
     const allDefs = getAllToolDefinitions();
 
@@ -44,23 +44,31 @@ describe("always-loaded tool count", () => {
     );
     const activeNames = activeTools.map((t) => t.name).sort();
 
-    // Host tools (host_bash, host_file_*) are excluded when no client is
-    // connected — without a human in the loop, the guardian auto-approve
-    // path would allow unchecked host command execution.
-    //
-    // `watch_retro_report` is here for the same reason the ui_surface tools are
-    // NOT: a watch retrospective runs clientless, so it can only report through
-    // a tool that survives this baseline. Its description and schema are kept
-    // deliberately terse because that is the cost of the slot.
+    // `watch_retro_report` survives this baseline because a watch
+    // retrospective runs clientless and can only report through a tool that
+    // stays on this baseline. The ui_* tools stay here because background
+    // surfaces persist and return instead of awaiting action, so a connected
+    // client is not required for the definitions to be present.
+    // Host tool definitions stay on the wire for background turns: schemas
+    // are cache-stable, and the shared execution gate rejects host tools on
+    // explicitly non-interactive turns before any proxy dispatch.
     const expectedNames = [
       "bash",
       "file_edit",
       "file_read",
       "file_write",
+      "host_bash",
+      "host_file_edit",
+      "host_file_read",
+      "host_file_transfer",
+      "host_file_write",
       "recall",
       "remember",
       "skill_execute",
       "skill_load",
+      "ui_dismiss",
+      "ui_show",
+      "ui_update",
       "watch_retro_report",
       "web_fetch",
       "web_search",
@@ -68,6 +76,6 @@ describe("always-loaded tool count", () => {
 
     expect(activeNames).toEqual(expectedNames);
     expect(activeNames.filter((name) => name === "recall")).toHaveLength(1);
-    expect(activeTools.length).toBe(11);
+    expect(activeTools.length).toBe(19);
   });
 });

package/src/__tests__/anthropic-provider.test.ts

@@ -3029,69 +3029,6 @@ describe("AnthropicProvider - internal attachment id", () => {
   });
 });
 
-// ---------------------------------------------------------------------------
-// Tests — Orphaned UTF-16 surrogate sanitization
-// ---------------------------------------------------------------------------
-
-describe("AnthropicProvider — surrogate sanitization", () => {
-  let provider: AnthropicProvider;
-
-  beforeEach(() => {
-    lastStreamParams = null;
-    provider = new AnthropicProvider("sk-ant-test", "claude-sonnet-4-6");
-  });
-
-  test("strips orphaned high surrogate from a tool result before sending", async () => {
-    // An orphaned high surrogate — the exact shape that triggers Anthropic's
-    // "no low surrogate in string" 400. The mock's JSON.parse(JSON.stringify)
-    // on line ~44 would throw if sanitization didn't happen.
-    const LONE_HIGH = "\uD83C";
-    const messages: Message[] = [
-      toolUseMsg("tu1", "bash"),
-      toolResultMsg("tu1", `shell output ${LONE_HIGH} more output`),
-      userMsg("what happened?"),
-    ];
-
-    await provider.sendMessage(messages);
-
-    const sent = lastStreamParams!.messages as Array<{
-      role: string;
-      content: Array<{ type: string; content?: string; text?: string }>;
-    }>;
-    // Find the tool_result block in the captured payload and assert no orphans.
-    const toolResult = sent
-      .flatMap((m) => m.content)
-      .find((b) => b.type === "tool_result");
-    expect(toolResult).toBeDefined();
-    expect(toolResult!.content).toBeDefined();
-    const content = toolResult!.content as string;
-    for (let i = 0; i < content.length; i++) {
-      const code = content.charCodeAt(i);
-      if (code >= 0xd800 && code <= 0xdbff) {
-        const next = i + 1 < content.length ? content.charCodeAt(i + 1) : 0;
-        expect(next >= 0xdc00 && next <= 0xdfff).toBe(true);
-        i++;
-      } else {
-        expect(code < 0xdc00 || code > 0xdfff).toBe(true);
-      }
-    }
-  });
-
-  test("clean payloads are not copied unnecessarily", async () => {
-    // When there are no orphans, the sanitizer should be a no-op. We can't
-    // easily assert reference equality through the mock boundary (the mock
-    // JSON-round-trips params for capture), but we can at least confirm the
-    // call succeeds without error on ordinary payloads containing valid
-    // surrogate pairs (emoji).
-    const EMOJI = "\uD83C\uDF89";
-    await provider.sendMessage([userMsg(`hello ${EMOJI} world`)]);
-    const sent = lastStreamParams!.messages as Array<{
-      content: Array<{ text?: string }>;
-    }>;
-    expect(sent[0].content[0].text).toContain(EMOJI);
-  });
-});
-
 // ---------------------------------------------------------------------------
 // Haiku model gating
 // ---------------------------------------------------------------------------

package/src/__tests__/app-compiler.test.ts

@@ -112,6 +112,12 @@ describe("compileApp", () => {
     const html = await readFile(join(appDir, "dist", "index.html"), "utf-8");
     expect(html).toContain('src="main.js"');
     expect(html).toContain('type="module"');
+
+    const fingerprint = JSON.parse(
+      await readFile(join(appDir, "dist", ".source-fingerprint.json"), "utf-8"),
+    ) as { algorithm: string; files: Record<string, string> };
+    expect(fingerprint.algorithm).toBe("sha256");
+    expect(fingerprint.files["src/main.tsx"]).toMatch(/^[0-9a-f]{64}$/);
   });
 
   test("compiles preact JSX correctly", async () => {

package/src/__tests__/app-control-tool-schemas.test.ts

@@ -591,8 +591,11 @@ describe("forwardAppControlProxyTool", () => {
       ctx,
     );
     expect(result.isError).toBe(true);
-    expect(result.content).toContain("no proxy resolver available");
-    expect(result.content).toContain("app_control_click");
+    expect(result.content).toContain(
+      "The Vellum desktop app is needed to control apps on your computer",
+    );
+    expect(result.content).toContain("https://www.vellum.ai/downloads");
+    expect(result.content).not.toContain("app_control_click");
   });
 
   test("delegates to proxy resolver when available", async () => {

package/src/__tests__/app-dir-path-guard.test.ts

@@ -9,15 +9,13 @@ import { describe, expect, test } from "bun:test";
  * This prevents regressions where new code bypasses the dirName-based path
  * resolution and constructs UUID-based paths directly.
  *
- * Allowlist: only app-store.ts itself, app-source-watcher.ts (uses getAppsDir
- * for the fs.watch root, not for per-app paths), and workspace migrations
+ * Allowlist: only app-store.ts itself and workspace migrations
  * (self-contained, don't import from app-store).
  */
 
 /** Files that are permitted to import getAppsDir. */
 const ALLOWLIST = new Set([
   "assistant/src/apps/app-store.ts", // defines getAppsDir
-  "assistant/src/daemon/app-source-watcher.ts", // uses getAppsDir for recursive fs.watch root, not per-app paths
   "assistant/src/tools/filesystem/write.ts", // uses getAppsDir as an exemption root for the artifact-HTML guard, not per-app paths
 ]);
 

package/src/__tests__/approval-interception-trust-gates.test.ts

@@ -149,6 +149,46 @@ describe("approval interception trust-class gates", () => {
     expect(sessionMock).toHaveBeenCalled();
   });
 
+  test("guardian apr: callback naming no approval action is consumed as a stale button, never routed as text", async () => {
+    _anchorPrincipalId = "guardian-principal-1";
+    const sessionMock = registerPendingInteraction(
+      "req-guardian-retired-1",
+      CONVERSATION_ID,
+      TOOL_NAME,
+      TOOL_INPUT,
+    );
+
+    // The channel normalizers copy callback data into the message content, so
+    // a button press arrives with both set to the same string.
+    const callbackData = "apr:req-guardian-retired-1:approve_always";
+    const result = await handleApprovalInterception({
+      conversationId: CONVERSATION_ID,
+      callbackData,
+      content: callbackData,
+      conversationExternalId: REQUESTER_CHAT,
+      sourceChannel: "telegram",
+      actorExternalId: "guardian-user-1",
+      replyCallbackUrl: "https://gateway.test/deliver",
+      trustCtx: {
+        sourceChannel: "telegram",
+        trustClass: "guardian",
+        requesterExternalUserId: "guardian-user-1",
+        guardianExternalUserId: "guardian-user-1",
+        guardianPrincipalId: "guardian-principal-1",
+      },
+      assistantId: ASSISTANT_ID,
+    });
+
+    expect(result.handled).toBe(true);
+    expect(result.type).toBe("stale_ignored");
+    // No decision, and no reply: the text parsers never saw the callback.
+    expect(sessionMock).not.toHaveBeenCalled();
+    expect(deliverSpy).not.toHaveBeenCalled();
+    expect(pendingInteractions.getByConversation(CONVERSATION_ID)).toHaveLength(
+      1,
+    );
+  });
+
   test("guardian apr: callback with a principal NOT matching the anchor is rejected before any decision", async () => {
     _anchorPrincipalId = "the-real-guardian-principal";
     const sessionMock = registerPendingInteraction(

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

@@ -125,7 +125,10 @@ describe("AssistantEventHub — machineName", () => {
   });
 });
 
-describe("window capture negotiation", () => {
+describe.each([
+  ["x-vellum-cu-window-capture", "host_cu_window_capture"],
+  ["x-vellum-cu-sequence", "host_cu_sequence"],
+] as const)("%s negotiation", (header, capability) => {
   test.each([
     ["macos", undefined, false],
     ["macos", "0", false],
@@ -145,18 +148,14 @@ describe("window capture negotiation", () => {
             headers: {
               "x-vellum-client-id": "client-1",
               "x-vellum-interface-id": interfaceId,
-              ...(advertised
-                ? { "x-vellum-cu-window-capture": advertised }
-                : {}),
+              ...(advertised ? { [header]: advertised } : {}),
             },
             abortSignal: ac.signal,
           },
           { hub },
         );
         expect(
-          hub
-            .getClientById("client-1")
-            ?.capabilities.includes("host_cu_window_capture"),
+          hub.getClientById("client-1")?.capabilities.includes(capability),
         ).toBe(supported);
       } finally {
         ac.abort();