@vellumai/assistant 0.8.3 → 0.8.4

package/src/__tests__/pending-interactions-resolved-event.test.ts

@@ -0,0 +1,190 @@
+/**
+ * Verifies that every resolution path through
+ * `runtime/pending-interactions.ts` publishes an `interaction_resolved`
+ * envelope on the event hub with the right state.
+ *
+ * Each test registers an interaction directly and calls `resolve()` or
+ * `removeByConversation()` so we exercise the tracker in isolation
+ * without spinning up a Conversation, prompter, or proxy.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+import type { ServerMessage } from "../daemon/message-protocol.js";
+
+// Capture every broadcast emitted by the tracker. The real hub is replaced
+// with a thin recorder so we can assert payloads deterministically.
+const publishedMessages: ServerMessage[] = [];
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: ServerMessage) => {
+    publishedMessages.push(msg);
+  },
+  capabilityForMessageType: () => undefined,
+  assistantEventHub: {
+    publish: async () => {},
+    subscribe: () => ({ dispose: () => {}, active: true }),
+  },
+}));
+
+const pendingInteractions = await import("../runtime/pending-interactions.js");
+
+beforeEach(() => {
+  publishedMessages.length = 0;
+  pendingInteractions.clear();
+});
+
+afterEach(() => {
+  pendingInteractions.clear();
+});
+
+function lastResolvedEvent() {
+  const evt = publishedMessages.find((m) => m.type === "interaction_resolved");
+  expect(evt).toBeDefined();
+  return evt as Extract<ServerMessage, { type: "interaction_resolved" }>;
+}
+
+describe("pendingInteractions.resolve emits interaction_resolved", () => {
+  test("default state is 'cancelled'", () => {
+    pendingInteractions.register("req-1", {
+      conversationId: "conv-1",
+      kind: "confirmation",
+    });
+    const returned = pendingInteractions.resolve("req-1");
+    expect(returned).toBeDefined();
+    const evt = lastResolvedEvent();
+    expect(evt.requestId).toBe("req-1");
+    expect(evt.conversationKey).toBe("conv-1");
+    expect(evt.conversationId).toBe("conv-1");
+    expect(evt.state).toBe("cancelled");
+    expect(evt.kind).toBe("confirmation");
+  });
+
+  test("approved state propagates", () => {
+    pendingInteractions.register("req-approve", {
+      conversationId: "conv-a",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-approve", "approved");
+    expect(lastResolvedEvent().state).toBe("approved");
+  });
+
+  test("rejected state propagates", () => {
+    pendingInteractions.register("req-reject", {
+      conversationId: "conv-b",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-reject", "rejected");
+    expect(lastResolvedEvent().state).toBe("rejected");
+  });
+
+  test("answered state propagates (secret response)", () => {
+    pendingInteractions.register("req-secret", {
+      conversationId: "conv-c",
+      kind: "secret",
+    });
+    pendingInteractions.resolve("req-secret", "answered");
+    const evt = lastResolvedEvent();
+    expect(evt.state).toBe("answered");
+    expect(evt.kind).toBe("secret");
+  });
+
+  test("superseded state propagates", () => {
+    pendingInteractions.register("req-super", {
+      conversationId: "conv-d",
+      kind: "confirmation",
+    });
+    pendingInteractions.resolve("req-super", "superseded");
+    expect(lastResolvedEvent().state).toBe("superseded");
+  });
+
+  test("no event is emitted when the requestId is unknown", () => {
+    pendingInteractions.resolve("never-registered", "approved");
+    expect(publishedMessages).toHaveLength(0);
+  });
+
+  test("a single resolve emits exactly one event", () => {
+    pendingInteractions.register("req-once", {
+      conversationId: "conv-e",
+      kind: "host_bash",
+    });
+    pendingInteractions.resolve("req-once", "answered");
+    // Second resolve is a no-op because the entry was already consumed.
+    pendingInteractions.resolve("req-once", "answered");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+  });
+
+  test("clears the registered timer on resolve", () => {
+    let fired = false;
+    const timer = setTimeout(() => {
+      fired = true;
+    }, 10_000);
+    pendingInteractions.register("req-timer", {
+      conversationId: "conv-f",
+      kind: "confirmation",
+      timer,
+    });
+    pendingInteractions.resolve("req-timer", "approved");
+    clearTimeout(timer);
+    expect(fired).toBe(false);
+  });
+});
+
+describe("removeByConversation emits interaction_resolved per entry", () => {
+  test("emits superseded for every non-host interaction in the conversation", () => {
+    pendingInteractions.register("conf-1", {
+      conversationId: "conv-x",
+      kind: "confirmation",
+    });
+    pendingInteractions.register("secret-1", {
+      conversationId: "conv-x",
+      kind: "secret",
+    });
+    pendingInteractions.register("question-1", {
+      conversationId: "conv-x",
+      kind: "question",
+    });
+    pendingInteractions.register("host-bash-1", {
+      conversationId: "conv-x",
+      kind: "host_bash",
+    });
+    pendingInteractions.register("conf-other", {
+      conversationId: "conv-y",
+      kind: "confirmation",
+    });
+
+    pendingInteractions.removeByConversation("conv-x");
+
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    ) as Extract<ServerMessage, { type: "interaction_resolved" }>[];
+    expect(events).toHaveLength(3);
+    expect(events.every((e) => e.state === "superseded")).toBe(true);
+    const requestIds = new Set(events.map((e) => e.requestId));
+    expect(requestIds).toEqual(new Set(["conf-1", "secret-1", "question-1"]));
+
+    // host_bash entries survive auto-deny — no event for them.
+    expect(pendingInteractions.get("host-bash-1")).toBeDefined();
+    // Unrelated conversation is untouched.
+    expect(pendingInteractions.get("conf-other")).toBeDefined();
+  });
+
+  test("explicit state arg overrides the default 'superseded'", () => {
+    pendingInteractions.register("conf-2", {
+      conversationId: "conv-z",
+      kind: "confirmation",
+    });
+    pendingInteractions.removeByConversation("conv-z", "cancelled");
+    const events = publishedMessages.filter(
+      (m) => m.type === "interaction_resolved",
+    );
+    expect(events).toHaveLength(1);
+    expect(
+      (events[0] as Extract<ServerMessage, { type: "interaction_resolved" }>)
+        .state,
+    ).toBe("cancelled");
+  });
+});

package/src/__tests__/platform.test.ts

@@ -8,7 +8,6 @@ import {
   getDataDir,
   getDbPath,
   getHistoryPath,
-  getInterfacesDir,
   getLogPath,
   getPidPath,
   getSandboxRootDir,
@@ -67,7 +66,6 @@ describe("path characterization", () => {
     expect(getDbPath()).toBe(join(data, "db", "assistant.db"));
     expect(getLogPath()).toBe(join(data, "logs", "vellum.log"));
     expect(getHistoryPath()).toBe(join(data, "history"));
-    expect(getInterfacesDir()).toBe(join(data, "interfaces"));
     expect(getSandboxRootDir()).toBe(join(data, "sandbox"));
     expect(getSandboxWorkingDir()).toBe(ws);
 
@@ -117,7 +115,6 @@ describe("path characterization", () => {
     expect(existsSync(join(data, "memory"))).toBe(true);
     expect(existsSync(join(data, "memory", "knowledge"))).toBe(true);
     expect(existsSync(join(data, "apps"))).toBe(true);
-    expect(existsSync(join(data, "interfaces"))).toBe(true);
 
     rmSync(wsDir, { recursive: true, force: true });
   });

package/src/__tests__/plugin-source-watcher.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Tests for PluginSourceWatcher — filesystem watcher that detects plugin
+ * directory changes and triggers debounced reregistration.
+ *
+ * Key regression: the watcher must survive (and recover from) the Linux/Bun
+ * recursive-watch limitation where subdirectories created after watch starts
+ * are silently dropped. We test that close→reopen + rescan catches these.
+ */
+
+import { afterEach, beforeEach, describe, expect, mock, test } from "bun:test";
+
+// ---------------------------------------------------------------------------
+// Mocks — must be set up before importing the module under test
+// ---------------------------------------------------------------------------
+
+const TEST_PLUGINS_DIR = "/tmp/test-plugins";
+
+let capturedWatchCallback:
+  | ((eventType: string, filename: string | null) => void)
+  | null = null;
+let mockWatchShouldThrow = false;
+const mockWatcher = { close: mock(() => {}) };
+
+const mockWatch = mock(
+  (
+    _path: string,
+    _opts: Record<string, unknown>,
+    callback: (eventType: string, filename: string | null) => void,
+  ) => {
+    if (mockWatchShouldThrow) throw new Error("watch failed");
+    capturedWatchCallback = callback;
+    return mockWatcher;
+  },
+);
+
+const mockRereadirSync = mock((_path: string): string[] => []);
+
+let mockGetRegisteredPluginImpl: (name: string) => unknown | undefined = (
+  _name,
+) => undefined;
+const mockGetRegisteredPlugin = mock((name: string) =>
+  mockGetRegisteredPluginImpl(name),
+);
+
+let mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+const mockReregisterExternalPlugin = mock(async (name: string) =>
+  mockReregisterExternalPluginImpl(name),
+);
+
+mock.module("node:fs", () => {
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const actualFs = require("node:fs");
+  return {
+    ...actualFs,
+    watch: mockWatch,
+    readdirSync: mockRereadirSync,
+  };
+});
+
+mock.module("../plugins/registry.js", () => ({
+  getRegisteredPlugin: mockGetRegisteredPlugin,
+}));
+
+mock.module("../util/platform.js", () => ({
+  getWorkspacePluginsDir: mock(() => TEST_PLUGINS_DIR),
+}));
+
+mock.module("../daemon/external-plugins-bootstrap.js", () => ({
+  reregisterExternalPlugin: mockReregisterExternalPlugin,
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: mock(() => ({
+    info: mock(() => {}),
+    warn: mock(() => {}),
+  })),
+}));
+
+// ---------------------------------------------------------------------------
+// Import after mocks
+// ---------------------------------------------------------------------------
+
+import { PluginSourceWatcher } from "../daemon/plugin-source-watcher.js";
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+describe("PluginSourceWatcher", () => {
+  beforeEach(() => {
+    PluginSourceWatcher.resetForTests();
+    capturedWatchCallback = null;
+    mockWatchShouldThrow = false;
+    mockWatcher.close.mockClear();
+    mockWatch.mockClear();
+    mockRereadirSync.mockClear();
+    mockGetRegisteredPlugin.mockClear();
+    mockReregisterExternalPlugin.mockClear();
+    mockGetRegisteredPluginImpl = (_name: string) => undefined;
+    mockReregisterExternalPluginImpl = mock(async (_name: string) => {});
+  });
+
+  afterEach(() => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.stop();
+  });
+
+  test("start() creates a recursive watcher on the plugins directory", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("plugin directory creation triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin");
+
+    // Wait for debounce
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("nested file change within plugin triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("deeply nested file change triggers rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/handlers/util/helper.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("dotfiles in plugins root are ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", ".DS_Store");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("null filename is ignored", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", null);
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("rapid changes to same plugin are debounced into single rebuild", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    capturedWatchCallback!("change", "my-plugin/src/handlers.ts");
+    capturedWatchCallback!("change", "my-plugin/package.json");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(1);
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledWith("my-plugin");
+  });
+
+  test("changes to different plugins trigger separate rebuilds (debounced)", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "plugin-a/src/index.ts");
+    capturedWatchCallback!("change", "plugin-b/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+    expect(mockReregisterExternalPlugin).toHaveBeenCalledTimes(2);
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(1, "plugin-a");
+    expect(mockReregisterExternalPlugin).toHaveBeenNthCalledWith(2, "plugin-b");
+  });
+
+  test("stop() closes watcher and cancels pending rebuilds", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+    watcher.stop();
+
+    expect(mockWatcher.close).toHaveBeenCalledTimes(1);
+    // No rebuild should fire after stop
+    expect(mockReregisterExternalPlugin).not.toHaveBeenCalled();
+  });
+
+  test("ensureStarted() initializes watcher after start() if watch coverage was lost", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    expect(capturedWatchCallback).not.toBeNull();
+
+    // Simulate lost coverage while the daemon lifecycle is still started
+    // (e.g. a previous watch attempt failed after startup).
+    (watcher as unknown as { watcher: unknown }).watcher = null;
+    capturedWatchCallback = null;
+
+    watcher.ensureStarted();
+    expect(capturedWatchCallback).not.toBeNull();
+  });
+
+  test("ensureStarted() is a no-op when watcher is already running", () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const callCountAfterStart = mockWatch.mock.calls.length;
+
+    watcher.ensureStarted();
+    expect(mockWatch.mock.calls.length).toBe(callCountAfterStart);
+  });
+
+  test("watcher restart keeps the previous watcher active if replacement fails", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+    const firstCallback = capturedWatchCallback;
+
+    mockWatchShouldThrow = true;
+    capturedWatchCallback!("change", "my-plugin/src/index.ts");
+
+    await new Promise((r) => setTimeout(r, 600));
+
+    expect(mockWatcher.close).not.toHaveBeenCalled();
+    expect((watcher as unknown as { watcher: unknown }).watcher).toBe(
+      mockWatcher,
+    );
+    expect(capturedWatchCallback).toBe(firstCallback);
+  });
+
+  test("singleton instance is shared across calls", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    const watcher2 = PluginSourceWatcher.getInstance();
+    expect(watcher1).toBe(watcher2);
+  });
+
+  test("resetForTests() clears the singleton", () => {
+    const watcher1 = PluginSourceWatcher.getInstance();
+    watcher1.start();
+
+    PluginSourceWatcher.resetForTests();
+    const watcher2 = PluginSourceWatcher.getInstance();
+
+    expect(watcher1).not.toBe(watcher2);
+  });
+
+  /**
+   * REGRESSION: When an event arrives during a close→reopen swap, rescan
+   * must catch any plugin not yet in the registry.
+   *
+   * Scenario:
+   * 1. Plugin "new-plugin" directory is created
+   * 2. Event fires, triggering a watcher restart (close + reopen)
+   * 3. Before the old watcher's callback is fully fired, another plugin
+   *    "late-plugin" is created
+   * 4. The new watcher doesn't yet know about "late-plugin"
+   * 5. After the reopen, rescan walks the directory and finds "late-plugin"
+   *    not in the registry, and schedules its rebuild
+   */
+  test("watcher restart + rescan catches plugins created during close→reopen", async () => {
+    const watcher = PluginSourceWatcher.getInstance();
+    watcher.start();
+
+    // Track which plugins are "registered" at each point
+    const registeredPlugins = new Set<string>();
+    mockGetRegisteredPluginImpl = (name: string) =>
+      registeredPlugins.has(name) ? { name } : undefined;
+
+    // Simulate multiple plugins on disk
+    mockRereadirSync.mockImplementation(() => [
+      "new-plugin",
+      "late-plugin",
+      ".DS_Store",
+    ]);
+
+    // Fire an event on new-plugin (this will trigger a watcher restart)
+    capturedWatchCallback!("change", "new-plugin/src/index.ts");
+
+    // Wait for the direct rebuild debounce, the watcher-restart debounce,
+    // and the rescan-triggered rebuild debounce.
+    await new Promise((r) => setTimeout(r, 1100));
+
+    // At this point, rescan should have run and discovered late-plugin,
+    // even though no direct fs.watch event was delivered for it.
+    const calls = mockReregisterExternalPlugin.mock.calls.map((c) => c[0]);
+    expect(calls).toContain("new-plugin");
+    expect(calls).toContain("late-plugin");
+    expect(calls).not.toContain(".DS_Store");
+  });
+});

package/src/__tests__/process-message-background-slack.test.ts

@@ -95,7 +95,6 @@ type PersistUserMessageMock = ReturnType<
 type RunAgentLoopMock = ReturnType<
   typeof mock<(...args: unknown[]) => Promise<void>>
 >;
-type NoticeMock = ReturnType<typeof mock<(notice: string | undefined) => void>>;
 interface TestConversation {
   conversationId: string;
   trustContext: unknown;
@@ -123,13 +122,10 @@ interface TestConversation {
     estimatedCost: number;
   };
   persistUserMessage: PersistUserMessageMock;
-  setSlackRuntimeContextNotice: NoticeMock;
   runAgentLoop: RunAgentLoopMock;
   updateClient: (sender: (...args: unknown[]) => void) => void;
   getCurrentSender: () => ((...args: unknown[]) => void) | undefined;
   __loopDeferred: Deferred<void>;
-  __noticeCalls: Array<string | undefined>;
-  __loopNotices: Array<string | undefined>;
   __clientSenders: Array<((...args: unknown[]) => void) | undefined>;
 }
 
@@ -171,11 +167,8 @@ async function waitForRunAgentLoopCall(): Promise<void> {
 function makeConversation(): TestConversation {
   let turnChannelContext: TurnChannelContext | null = null;
   let turnInterfaceContext: TurnInterfaceContext | null = null;
-  let slackNotice: string | undefined;
   let currentSender: ((...args: unknown[]) => void) | undefined;
-  const noticeCalls: Array<string | undefined> = [];
   const loopDeferred = createDeferred<void>();
-  const loopNotices: Array<string | undefined> = [];
   const clientSenders: Array<((...args: unknown[]) => void) | undefined> = [];
   const messages: unknown[] = [];
 
@@ -223,12 +216,7 @@ function makeConversation(): TestConversation {
         _metadata?: Record<string, unknown>,
       ) => "persisted-user-message-id",
     ),
-    setSlackRuntimeContextNotice: mock((notice: string | undefined) => {
-      slackNotice = notice;
-      noticeCalls.push(notice);
-    }),
     runAgentLoop: mock(async (..._args: unknown[]) => {
-      loopNotices.push(slackNotice);
       await loopDeferred.promise;
     }),
     updateClient: (sender: (...args: unknown[]) => void) => {
@@ -237,8 +225,6 @@ function makeConversation(): TestConversation {
     },
     getCurrentSender: () => currentSender,
     __loopDeferred: loopDeferred,
-    __noticeCalls: noticeCalls,
-    __loopNotices: loopNotices,
     __clientSenders: clientSenders,
   };
 
@@ -252,15 +238,13 @@ describe("processMessageInBackground Slack option propagation", () => {
     broadcastMessages.length = 0;
   });
 
-  test("passes Slack inbound metadata to persistence and exposes the runtime notice during the loop", async () => {
+  test("passes Slack inbound metadata to persistence during background processing", async () => {
     const slackInbound = {
       channelId: "C0123CHANNEL",
       channelTs: "1700000001.111111",
       threadTs: "1700000000.000001",
       displayName: "Alice",
     };
-    const notice =
-      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
 
     const result = await processMessageInBackground(
       "conv-background-slack",
@@ -268,7 +252,6 @@ describe("processMessageInBackground Slack option propagation", () => {
       undefined,
       {
         slackInbound,
-        slackRuntimeContextNotice: notice,
       },
       "slack",
       "slack",
@@ -280,43 +263,10 @@ describe("processMessageInBackground Slack option propagation", () => {
       slackInbound,
     });
     expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
-    expect(activeConversation.__loopNotices).toEqual([notice]);
 
     activeConversation.__loopDeferred.resolve();
     await activeConversation.__loopDeferred.promise;
     await Promise.resolve();
-
-    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
-  });
-
-  test("clears the Slack runtime notice after normal message processing", async () => {
-    const notice =
-      "Slack context note: this turn joined an existing thread. 2 earlier messages were backfilled.";
-
-    const processing = processMessage(
-      "conv-background-slack",
-      "Reply from Slack",
-      undefined,
-      {
-        slackRuntimeContextNotice: notice,
-        isInteractive: true,
-      },
-      "slack",
-      "slack",
-    );
-
-    await waitForRunAgentLoopCall();
-
-    expect(activeConversation.runAgentLoop).toHaveBeenCalledTimes(1);
-    expect(activeConversation.__loopNotices).toEqual([notice]);
-
-    activeConversation.__loopDeferred.resolve();
-    await expect(processing).resolves.toEqual({
-      messageId: "persisted-user-message-id",
-    });
-
-    expect(activeConversation.__noticeCalls).toEqual([notice, undefined]);
-    expect(activeConversation.__clientSenders).toHaveLength(2);
   });
 
   test("observes live agent events without replacing the broadcast emitter", async () => {

package/src/__tests__/process-message-display-content.test.ts

@@ -196,7 +196,6 @@ function makeTestConversation() {
         metadata,
         displayContent,
       ),
-    setSlackRuntimeContextNotice: () => {},
     runAgentLoop,
     updateClient: () => {},
     getCurrentSender: () => undefined,
@@ -361,6 +360,7 @@ describe("processMessage displayContent", () => {
     expect(persistedBlocks).toEqual([
       {
         type: "file",
+        _attachmentId: "att-1",
         source: {
           type: "base64",
           media_type: "application/pdf",
@@ -370,21 +370,26 @@ describe("processMessage displayContent", () => {
       },
     ]);
     expect(addMessageCalls[0]!.content).not.toContain("<external_content");
-    expect(conversation.getMessages()[0]).toEqual({
-      role: "user",
-      content: [
-        { type: "text", text: modelContent },
-        {
-          type: "file",
-          source: {
-            type: "base64",
-            media_type: "application/pdf",
-            data: Buffer.from("pdf bytes").toString("base64"),
-            filename: "attachment.pdf",
-          },
-          extracted_text: undefined,
-        },
-      ],
+    const inMemoryMessage = conversation.getMessages()[0]!;
+    expect(inMemoryMessage.role).toBe("user");
+    expect(inMemoryMessage.content[0]).toEqual({
+      type: "text",
+      text: modelContent,
+    });
+    const inMemoryFileBlock = inMemoryMessage.content[1] as unknown as Record<
+      string,
+      unknown
+    >;
+    expect(inMemoryFileBlock._attachmentId).toBe("att-1");
+    expect(inMemoryFileBlock).toMatchObject({
+      type: "file",
+      source: {
+        type: "base64",
+        media_type: "application/pdf",
+        data: Buffer.from("pdf bytes").toString("base64"),
+        filename: "attachment.pdf",
+      },
+      extracted_text: undefined,
     });
   });