@vellumai/assistant 0.10.4 → 0.10.5-dev.202607022329.d89bf2f

package/src/context/outbound-sanitize.ts

@@ -0,0 +1,202 @@
+/**
+ * Outbound-request history sanitization shared by every provider call that
+ * sends conversation history: the agent loop's model calls and the
+ * compactor's summary calls. Each transform derives a sanitized projection of
+ * the outbound copy only — durable history keeps the rich originals, and every
+ * transform is idempotent so each send re-derives the same projection.
+ */
+
+import { stripHistoricalWebSearchResults } from "../daemon/web-search-history.js";
+import type {
+  ContentBlock,
+  Message,
+  ToolResultContent,
+} from "../providers/types.js";
+
+/** Number of most-recent AX tree snapshots to keep in conversation history. */
+const MAX_AX_TREES_IN_HISTORY = 2;
+
+/** Regex that matches the `<ax-tree>...</ax-tree>` markers. */
+const AX_TREE_PATTERN = /<ax-tree>[\s\S]*?<\/ax-tree>/g;
+const AX_TREE_PLACEHOLDER = "<ax_tree_omitted />";
+
+/**
+ * Escapes any literal `</ax-tree>` occurrences inside AX tree content so
+ * that the non-greedy compaction regex (`AX_TREE_PATTERN`) does not stop
+ * prematurely when the user happens to be viewing XML/HTML source that
+ * contains the closing tag.  The escaped content does not need to be
+ * unescaped because compaction replaces the entire block with a placeholder.
+ */
+export function escapeAxTreeContent(content: string): string {
+  return content.replace(/<\/ax-tree>/gi, "&lt;/ax-tree&gt;");
+}
+
+/**
+ * Returns a shallow copy of `messages` where all but the most recent
+ * `MAX_AX_TREES_IN_HISTORY` `<ax-tree>` blocks have been replaced with a
+ * short placeholder.  This keeps the conversation context small so that
+ * TTFT does not grow linearly with step count in computer-use sessions.
+ *
+ * Counting is per-block, not per-message — a single user message can
+ * contain multiple tool_result blocks each with their own AX tree snapshot.
+ */
+export function compactAxTreeHistory(messages: Message[]): Message[] {
+  // Collect (messageIndex, blockIndex) for every tool_result block with <ax-tree>
+  const axBlocks: Array<{ msgIdx: number; blockIdx: number }> = [];
+  for (let i = 0; i < messages.length; i++) {
+    const msg = messages[i];
+    if (msg.role !== "user") {
+      continue;
+    }
+    for (let j = 0; j < msg.content.length; j++) {
+      const block = msg.content[j];
+      if (
+        block.type === "tool_result" &&
+        typeof block.content === "string" &&
+        block.content.includes("<ax-tree>")
+      ) {
+        axBlocks.push({ msgIdx: i, blockIdx: j });
+      }
+    }
+  }
+
+  if (axBlocks.length <= MAX_AX_TREES_IN_HISTORY) {
+    return messages;
+  }
+
+  // Build a set of "msgIdx:blockIdx" keys for blocks that should be stripped
+  const toStrip = new Set(
+    axBlocks
+      .slice(0, -MAX_AX_TREES_IN_HISTORY)
+      .map((b) => `${b.msgIdx}:${b.blockIdx}`),
+  );
+
+  return messages.map((msg, idx) => {
+    // Quick check: does this message have any blocks to strip?
+    const hasStripTarget = msg.content.some((_, j) =>
+      toStrip.has(`${idx}:${j}`),
+    );
+    if (!hasStripTarget) {
+      return msg;
+    }
+
+    return {
+      ...msg,
+      content: msg.content.map((block, j) => {
+        if (
+          toStrip.has(`${idx}:${j}`) &&
+          block.type === "tool_result" &&
+          typeof block.content === "string"
+        ) {
+          return {
+            ...block,
+            content: block.content.replace(
+              AX_TREE_PATTERN,
+              AX_TREE_PLACEHOLDER,
+            ),
+          };
+        }
+        return block;
+      }),
+    };
+  });
+}
+
+/**
+ * Strip image contentBlocks from all tool_result blocks except those in the
+ * most recent user message that contains tool_result blocks. This prevents
+ * screenshots from accumulating in the context window — each image is seen
+ * once by the LLM on the turn it was captured, then replaced with a text
+ * placeholder on subsequent turns.
+ *
+ * We target the last user message with tool_results (not just the last user
+ * message) because a plain-text user message may follow the tool-result
+ * turn. Using the last user message unconditionally would leave the most
+ * recent tool screenshots unprotected from stripping.
+ */
+function stripOldMediaBlocks(history: Message[]): Message[] {
+  // Find the last user message that contains tool_result blocks.
+  let lastToolResultUserIdx = -1;
+  for (let i = history.length - 1; i >= 0; i--) {
+    if (
+      history[i].role === "user" &&
+      history[i].content.some((b) => b.type === "tool_result")
+    ) {
+      lastToolResultUserIdx = i;
+      break;
+    }
+  }
+
+  return history.map((msg, idx) => {
+    // Keep the most recent tool-result user message intact (current turn)
+    if (idx === lastToolResultUserIdx || msg.role !== "user") {
+      return msg;
+    }
+
+    // Check if any tool_result blocks carry embedded media (image or audio).
+    const isMedia = (cb: ContentBlock) =>
+      cb.type === "image" || cb.type === "file";
+    const hasMedia = msg.content.some(
+      (b) =>
+        b.type === "tool_result" &&
+        (b as ToolResultContent).contentBlocks?.some(isMedia),
+    );
+    if (!hasMedia) {
+      return msg;
+    }
+
+    // Strip media from tool_result blocks, replacing with a text marker. The
+    // model already saw/heard the media in the turn it was captured; resending
+    // the bytes every turn (a 12 MB audio clip isn't optimized like images)
+    // bloats the request until compaction.
+    return {
+      ...msg,
+      content: msg.content.map((b) => {
+        if (b.type !== "tool_result") {
+          return b;
+        }
+        const tr = b as ToolResultContent;
+        if (!tr.contentBlocks?.some(isMedia)) {
+          return b;
+        }
+        return {
+          ...tr,
+          contentBlocks: undefined,
+          content:
+            (tr.content || "") +
+            "\n[Media (image/audio) was captured and shown previously — binary data removed to save context.]",
+        };
+      }),
+    };
+  });
+}
+
+/**
+ * Sanitize the outbound history immediately before a provider call, bundling
+ * the pre-send transforms applied to every request that carries conversation
+ * history:
+ * - {@link stripOldMediaBlocks} drops accumulated screenshot/audio bytes from
+ *   older tool results — the model saw the media on the turn it was captured.
+ *   Beyond context bloat, unstripped history can carry enough images to cross
+ *   Anthropic's many-image threshold, where a stricter per-image dimension
+ *   cap applies and a single large screenshot rejects the whole request.
+ * - {@link compactAxTreeHistory} collapses all but the most recent few
+ *   `<ax-tree>` snapshots so TTFT does not grow linearly with step count.
+ * - {@link stripHistoricalWebSearchResults} converts historical
+ *   `web_search_tool_result` blocks to text summaries; Anthropic's opaque
+ *   `encrypted_content` tokens expire / are route-scoped, and replaying a stale
+ *   one is rejected with `Invalid encrypted_content in search_result block`.
+ *
+ * Transforms the outbound copy only — the durable history keeps the rich
+ * originals and each send re-derives the sanitized projection (every transform
+ * is idempotent). Both the agent loop's model calls and the compactor's
+ * summary calls funnel through this bundle, so their request prefixes stay
+ * byte-aligned (the summary call reuses the agent's warm prompt cache) and
+ * oversized media and expired web-search tokens are guaranteed to be removed
+ * from every request.
+ */
+export function preModelCallSanitize(history: Message[]): Message[] {
+  const mediaStripped = stripOldMediaBlocks(history);
+  const axCompacted = compactAxTreeHistory(mediaStripped);
+  return stripHistoricalWebSearchResults(axCompacted).messages;
+}

package/src/daemon/__tests__/abort-null-controller.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Abort contract when there is no live controller to signal.
+ *
+ * `abortConversation` signals `ctx.abortController?.abort()` and otherwise
+ * defers clearing the `processing` flag to the in-flight turn's `finally`.
+ * That deferral is only safe while a turn is actually live to reach its
+ * `finally`. The agent-loop `finally` nulls `abortController` *before* it
+ * clears the flag, and some paths set `processing` without ever installing a
+ * controller — so a conversation can be `isProcessing() === true` with a null
+ * `abortController`. In that state the old `?.abort()` was a silent no-op and
+ * nothing ever cleared the flag: every later submit was rejected with
+ * "already processing" and Stop did nothing.
+ *
+ * This pins the fix: when asked to abort while processing with no live
+ * controller, `abortConversation` force-clears the flag itself; when a
+ * controller IS live, it signals it and leaves the flag to the turn.
+ */
+import { describe, expect, mock, test } from "bun:test";
+
+// `conversation-lifecycle` transitively imports the messaging markdown
+// renderers, which pull in `hast`/`mdast`/`remark`/`unified`. Those packages
+// are declared in `assistant/package.json` but absent from this sandbox's
+// partial node_modules install (CI has the full set). `abortConversation`
+// never touches message rendering, so stub these leaf modules — the only ones
+// importing the missing packages — with no-op named exports so the import
+// graph resolves. Bun validates named imports statically, hence the explicit
+// keys rather than a Proxy.
+mock.module("../../messaging/content/parse.js", () => ({
+  parseMarkdown: () => ({}),
+}));
+mock.module("../../messaging/providers/slack/render.js", () => ({
+  renderSlackBlocks: () => undefined,
+  renderSlack: () => [],
+}));
+mock.module("../../messaging/providers/telegram-bot/render.js", () => ({
+  renderTelegramHtml: () => undefined,
+}));
+
+const { abortConversation } = await import("../conversation-lifecycle.js");
+import type { AbortContext } from "../conversation-lifecycle.js";
+
+interface Harness {
+  ctx: AbortContext;
+  setProcessingCalls: boolean[];
+  prompterDisposed: () => boolean;
+  secretPrompterDisposed: () => boolean;
+  queueClearedCount: () => number;
+}
+
+function makeContext(opts: {
+  processing: boolean;
+  controller: AbortController | null;
+}): Harness {
+  let processing = opts.processing;
+  const setProcessingCalls: boolean[] = [];
+  let prompterDisposed = false;
+  let secretPrompterDisposed = false;
+  let queueCleared = 0;
+
+  const ctx = {
+    conversationId: "abort-null-controller-test",
+    isProcessing: () => processing,
+    setProcessing: (value: boolean) => {
+      setProcessingCalls.push(value);
+      processing = value;
+    },
+    abortController: opts.controller,
+    prompter: {
+      dispose: () => {
+        prompterDisposed = true;
+      },
+    },
+    secretPrompter: {
+      dispose: () => {
+        secretPrompterDisposed = true;
+      },
+    },
+    pendingSurfaceActions: new Map(),
+    surfaceActionRequestIds: new Set(),
+    surfaceState: new Map(),
+    accumulatedSurfaceState: new Map(),
+    queue: {
+      clear: () => {
+        queueCleared += 1;
+      },
+      [Symbol.iterator]: function* () {
+        // no queued messages
+      },
+    },
+  } as unknown as AbortContext;
+
+  return {
+    ctx,
+    setProcessingCalls,
+    prompterDisposed: () => prompterDisposed,
+    secretPrompterDisposed: () => secretPrompterDisposed,
+    queueClearedCount: () => queueCleared,
+  };
+}
+
+describe("abortConversation", () => {
+  test("force-clears the flag when processing with no live controller", () => {
+    // GIVEN a conversation flagged processing but with no controller to signal
+    const h = makeContext({ processing: true, controller: null });
+
+    // WHEN an abort is requested
+    abortConversation(h.ctx);
+
+    // THEN the flag is force-cleared so the conversation is no longer wedged
+    expect(h.setProcessingCalls).toContain(false);
+    expect(h.ctx.isProcessing()).toBe(false);
+    // AND the rest of the teardown still ran
+    expect(h.prompterDisposed()).toBe(true);
+    expect(h.secretPrompterDisposed()).toBe(true);
+    expect(h.queueClearedCount()).toBe(1);
+  });
+
+  test("signals a live controller and defers the flag to the turn's finally", () => {
+    // GIVEN a conversation with a live, un-aborted controller
+    const controller = new AbortController();
+    const h = makeContext({ processing: true, controller });
+
+    // WHEN an abort is requested
+    abortConversation(h.ctx);
+
+    // THEN the controller is signalled
+    expect(controller.signal.aborted).toBe(true);
+    // AND the flag is NOT force-cleared here — the turn's `finally` owns that
+    expect(h.setProcessingCalls).not.toContain(false);
+    expect(h.ctx.isProcessing()).toBe(true);
+    // AND the shared teardown still ran
+    expect(h.prompterDisposed()).toBe(true);
+    expect(h.queueClearedCount()).toBe(1);
+  });
+
+  test("propagates the abort reason to the live controller", () => {
+    // GIVEN a live controller and an explicit abort reason
+    const controller = new AbortController();
+    const h = makeContext({ processing: true, controller });
+    let observedReason: unknown;
+    controller.signal.addEventListener("abort", () => {
+      observedReason = controller.signal.reason;
+    });
+
+    // WHEN aborting with no explicit reason (a default reason is synthesized)
+    abortConversation(h.ctx);
+
+    // THEN the controller's reason carries the tagged AbortReason
+    expect(observedReason).toBeDefined();
+    expect((observedReason as { kind?: string }).kind).toBe(
+      "preempted_by_new_message",
+    );
+  });
+
+  test("is a no-op when the conversation is not processing", () => {
+    // GIVEN a conversation that is not processing
+    const h = makeContext({ processing: false, controller: null });
+
+    // WHEN an abort is requested
+    abortConversation(h.ctx);
+
+    // THEN nothing is torn down and the flag is never touched
+    expect(h.setProcessingCalls).toEqual([]);
+    expect(h.prompterDisposed()).toBe(false);
+    expect(h.queueClearedCount()).toBe(0);
+  });
+});

package/src/daemon/__tests__/conversation-tool-setup-plugin-scope.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Tests for the per-chat plugin scope applied inside
+ * `createResolveToolsCallback`. When a conversation has an `enabledPlugins`
+ * set, only tools whose owning plugin id is in that set appear in the resolved
+ * per-turn tool list; core tools are unaffected. `null` (no per-chat
+ * restriction) leaves the list unchanged.
+ */
+
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test";
+
+import * as configLoader from "../../config/loader.js";
+import type { AssistantConfig } from "../../config/schema.js";
+import type { ToolDefinition } from "../../providers/types.js";
+import {
+  __clearRegistryForTesting,
+  registerPluginTools,
+} from "../../tools/registry.js";
+import type { Tool } from "../../tools/types.js";
+import { createResolveToolsCallback } from "../conversation-tool-setup.js";
+
+type SkillProjectionContext =
+  import("../conversation-tool-setup.js").SkillProjectionContext;
+type SkillProjectionCache =
+  import("../conversation-skill-tools.js").SkillProjectionCache;
+
+function def(name: string): ToolDefinition {
+  return { name, description: name, input_schema: { type: "object" } };
+}
+
+function pluginTool(name: string): Tool {
+  return {
+    name,
+    description: name,
+    input_schema: def(name).input_schema,
+  } as unknown as Tool;
+}
+
+function makeCtx(
+  overrides: Partial<SkillProjectionContext> = {},
+): SkillProjectionContext {
+  return {
+    skillProjectionState: new Map(),
+    skillProjectionCache: { fingerprints: new Map() } as SkillProjectionCache,
+    coreToolNames: new Set<string>(),
+    toolsDisabledDepth: 0,
+    ...overrides,
+  };
+}
+
+let getConfigSpy: ReturnType<typeof spyOn> | undefined;
+
+beforeEach(() => {
+  __clearRegistryForTesting();
+  // Resolver reads getConfig().tools.exclude; stub to an empty exclude so the
+  // test isolates the plugin-scope filter.
+  const stub: Partial<AssistantConfig> = { tools: { exclude: [] } };
+  getConfigSpy = spyOn(configLoader, "getConfig").mockReturnValue(
+    stub as AssistantConfig,
+  );
+});
+
+afterEach(() => {
+  getConfigSpy?.mockRestore();
+  getConfigSpy = undefined;
+  __clearRegistryForTesting();
+});
+
+describe("createResolveToolsCallback — per-chat plugin scope", () => {
+  test("set {a} keeps plugin a's tools and core tools, drops plugin b's", () => {
+    registerPluginTools("a", [pluginTool("a_tool")]);
+    registerPluginTools("b", [pluginTool("b_tool")]);
+
+    const resolver = createResolveToolsCallback(
+      [def("file_read")],
+      makeCtx({ enabledPlugins: ["a"] }),
+    );
+    const names = resolver!([]).map((d) => d.name);
+
+    expect(names).toContain("a_tool");
+    expect(names).toContain("file_read");
+    expect(names).not.toContain("b_tool");
+  });
+
+  test("null scope leaves all plugin tools in the resolved list", () => {
+    registerPluginTools("a", [pluginTool("a_tool")]);
+    registerPluginTools("b", [pluginTool("b_tool")]);
+
+    const resolver = createResolveToolsCallback(
+      [def("file_read")],
+      makeCtx({ enabledPlugins: null }),
+    );
+    const names = resolver!([]).map((d) => d.name);
+
+    expect(names).toContain("a_tool");
+    expect(names).toContain("b_tool");
+    expect(names).toContain("file_read");
+  });
+
+  test("absent enabledPlugins behaves like null (no restriction)", () => {
+    registerPluginTools("a", [pluginTool("a_tool")]);
+    registerPluginTools("b", [pluginTool("b_tool")]);
+
+    const resolver = createResolveToolsCallback([def("file_read")], makeCtx());
+    const names = resolver!([]).map((d) => d.name);
+
+    expect(names).toContain("a_tool");
+    expect(names).toContain("b_tool");
+  });
+
+  test("empty scope drops every plugin tool but keeps core tools", () => {
+    registerPluginTools("a", [pluginTool("a_tool")]);
+
+    const resolver = createResolveToolsCallback(
+      [def("file_read")],
+      makeCtx({ enabledPlugins: [] }),
+    );
+    const names = resolver!([]).map((d) => d.name);
+
+    expect(names).not.toContain("a_tool");
+    expect(names).toContain("file_read");
+  });
+});

package/src/daemon/__tests__/embedding-reconcile.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, mock, test } from "bun:test";
+import { afterAll, describe, expect, mock, test } from "bun:test";
 
 import type { AssistantConfig } from "../../config/types.js";
 import type { ReconcileAction } from "../../persistence/embeddings/reconcile-decision.js";
@@ -7,6 +7,52 @@ import {
   reconcileEmbeddingIdentity,
 } from "../embedding-reconcile.js";
 
+// Snapshot the real collaborator modules BEFORE any `mock.module` stub is
+// installed in `withDefaultDepsMocks`. `mock.module` is process-global and Bun
+// does not revert it (neither `mock.restore()` nor an `afterAll` re-mock) for
+// test files that load LATER in the same `bun test` run — notably the v3
+// `section-dense-store` suite, which imports the real module and asserts on its
+// create/index call counts. So every stub below DELEGATES to the real
+// implementation unless this file's default-deps tests are actively running
+// (`defaultDepsMockActive`, cleared in the `afterAll` below). Mirrors
+// `plugins/defaults/memory/v3/__tests__/shadow-plugin.test.ts`.
+//
+// Snapshot into plain objects NOW: a module namespace is a live view, so reading
+// a real export AFTER its stub is installed would resolve back to the stub.
+const realJobsStore = { ...(await import("../../persistence/jobs-store.js")) };
+const realMemoryV3Gate = {
+  ...(await import("../../config/memory-v3-gate.js")),
+};
+const realV2Qdrant = {
+  ...(await import("../../plugins/defaults/memory/v2/qdrant.js")),
+};
+const realLoader = { ...(await import("../../config/loader.js")) };
+const realSectionDenseStore = {
+  ...(await import("../../plugins/defaults/memory/v3/section-dense-store.js")),
+};
+
+let defaultDepsMockActive = false;
+
+afterAll(() => {
+  // Deactivate the delegating stubs so sibling suites that load later in a
+  // shared `bun test` process (e.g. section-dense-store.test.ts) observe the
+  // real modules instead of these spies.
+  defaultDepsMockActive = false;
+});
+
+/**
+ * Wrap a collaborator export so it routes to `active` while this file's
+ * default-deps tests run and to the real implementation otherwise. The choice is
+ * made at CALL time, so the stub keeps delegating to the real module for sibling
+ * suites that captured their import bindings while it was installed.
+ */
+function delegate<F extends (...args: never[]) => unknown>(
+  active: (...args: Parameters<F>) => unknown,
+  real: F,
+): (...args: Parameters<F>) => unknown {
+  return (...args) => (defaultDepsMockActive ? active(...args) : real(...args));
+}
+
 function fakeConfig(
   provider = "auto",
   opts: { enabled?: boolean; v2Enabled?: boolean } = {},
@@ -270,10 +316,16 @@ describe("reconcileEmbeddingIdentity", () => {
 // section-collection lifecycle without touching Qdrant, a backend, or config I/O.
 
 /**
- * Reset and re-install the mocks for the collaborator modules `defaultDeps`
- * pulls in, then re-import the module under test so its default deps close over
- * the freshly-mocked collaborators. Returns the spies plus a `defaultDeps`
- * factory bound to the re-imported module.
+ * Install the collaborator-module stubs `defaultDeps` pulls in, then re-import
+ * the module under test so its default deps close over them. Returns the spies
+ * plus a `defaultDeps` factory bound to the re-imported module.
+ *
+ * Each stub DELEGATES to the real module unless this file's default-deps tests
+ * are actively running (`defaultDepsMockActive`, set here and cleared in the
+ * file-level `afterAll`), so the process-global `mock.module` overrides do not
+ * leak into sibling suites that load later in the same `bun test` run. The
+ * delegation is decided at CALL time, so it stays correct regardless of when a
+ * later file captured its import bindings.
  */
 async function withDefaultDepsMocks(opts: {
   v3Live: boolean;
@@ -289,28 +341,59 @@ async function withDefaultDepsMocks(opts: {
     recreateConceptPageCollection: mock(async () => {}),
   };
 
+  defaultDepsMockActive = true;
+
   mock.module("../../persistence/jobs-store.js", () => ({
-    enqueueMemoryJob: spies.enqueueMemoryJob,
-    hasActiveJobOfType: spies.hasActiveJobOfType,
+    ...realJobsStore,
+    enqueueMemoryJob: delegate(
+      spies.enqueueMemoryJob,
+      realJobsStore.enqueueMemoryJob,
+    ),
+    hasActiveJobOfType: delegate(
+      spies.hasActiveJobOfType,
+      realJobsStore.hasActiveJobOfType,
+    ),
   }));
   mock.module("../../config/memory-v3-gate.js", () => ({
-    isMemoryV3Live: () => opts.v3Live,
+    ...realMemoryV3Gate,
+    isMemoryV3Live: delegate(
+      () => opts.v3Live,
+      realMemoryV3Gate.isMemoryV3Live,
+    ),
   }));
   mock.module("../../plugins/defaults/memory/v2/qdrant.js", () => ({
-    ensureConceptPageCollection: spies.ensureConceptPageCollection,
-    recreateConceptPageCollection: spies.recreateConceptPageCollection,
+    ...realV2Qdrant,
+    ensureConceptPageCollection: delegate(
+      spies.ensureConceptPageCollection,
+      realV2Qdrant.ensureConceptPageCollection,
+    ),
+    recreateConceptPageCollection: delegate(
+      spies.recreateConceptPageCollection,
+      realV2Qdrant.recreateConceptPageCollection,
+    ),
   }));
   mock.module("../../config/loader.js", () => ({
-    loadRawConfig: () => ({}),
-    saveRawConfig: () => {},
-    setNestedValue: () => {},
-    invalidateConfigCache: () => {},
+    ...realLoader,
+    loadRawConfig: delegate(() => ({}), realLoader.loadRawConfig),
+    saveRawConfig: delegate(() => undefined, realLoader.saveRawConfig),
+    setNestedValue: delegate(() => undefined, realLoader.setNestedValue),
+    invalidateConfigCache: delegate(
+      () => undefined,
+      realLoader.invalidateConfigCache,
+    ),
   }));
   mock.module(
     "../../plugins/defaults/memory/v3/section-dense-store.js",
     () => ({
-      ensureSectionCollection: spies.ensureSectionCollection,
-      recreateSectionCollection: spies.recreateSectionCollection,
+      ...realSectionDenseStore,
+      ensureSectionCollection: delegate(
+        spies.ensureSectionCollection,
+        realSectionDenseStore.ensureSectionCollection,
+      ),
+      recreateSectionCollection: delegate(
+        spies.recreateSectionCollection,
+        realSectionDenseStore.recreateSectionCollection,
+      ),
     }),
   );