@vellumai/assistant 0.12.1 → 0.12.2-staging.1

package/src/__tests__/mcp-list-plugin-servers.test.ts

@@ -68,17 +68,15 @@ mock.module("../daemon/mcp-reload-service.js", () => ({
   reloadMcpServers: async () => {},
 }));
 
-import { setConfig } from "./helpers/set-config.js";
+import { setWorkspaceMcp } from "./helpers/set-workspace-mcp.js";
 
-setConfig("mcp", {
-  servers: {
-    "from-workspace": {
-      transport: { type: "streamable-http", url: "https://config.example/mcp" },
-    },
-    // Deliberately shares an id with the `shadowed` plugin below.
-    shadowed: {
-      transport: { type: "streamable-http", url: "https://wins.example/mcp" },
-    },
+setWorkspaceMcp({
+  "from-workspace": {
+    transport: { type: "streamable-http", url: "https://config.example/mcp" },
+  },
+  // Deliberately shares an id with the `shadowed` plugin below.
+  shadowed: {
+    transport: { type: "streamable-http", url: "https://wins.example/mcp" },
   },
 });
 

package/src/__tests__/message-deleted-hook-dispatch.test.ts

@@ -0,0 +1,119 @@
+/**
+ * The `message-deleted` hook is dispatched by every primitive that removes
+ * individual message rows, carrying each row's `(createdAt, id)`, so a plugin
+ * keeping a cursor on a row learns where it sat once the row is gone.
+ * DB-backed: exercises the real delete primitives against the test database.
+ */
+import { beforeEach, describe, expect, test } from "bun:test";
+
+import { registerPluginHooks } from "../hooks/registry.js";
+import type { MessageDeletedContext } from "../hooks/types.js";
+import {
+  addMessage,
+  deleteLastExchange,
+  deleteMessageById,
+  getMessages,
+} from "../persistence/conversation-crud.js";
+import { getDb } from "../persistence/db-connection.js";
+import { initializeDb } from "../persistence/db-init.js";
+import { conversations, messages } from "../persistence/schema/index.js";
+import type { PluginHooks } from "../plugins/types.js";
+
+await initializeDb();
+
+const CONV_ID = "conv-message-deleted-hook";
+
+const received: Array<{
+  conversationId: string;
+  messageId: string;
+  createdAt: number;
+}> = [];
+registerPluginHooks("test-message-deleted-spy", {
+  "message-deleted": async (ctx: MessageDeletedContext) => {
+    received.push({
+      conversationId: ctx.conversationId,
+      messageId: ctx.messageId,
+      createdAt: ctx.createdAt,
+    });
+  },
+} as PluginHooks);
+
+/** Poll until the fire-and-forget hook chain has delivered `count` calls. */
+async function waitForCalls(count: number): Promise<void> {
+  const deadline = Date.now() + 2_000;
+  while (received.length < count && Date.now() < deadline) {
+    await Bun.sleep(10);
+  }
+}
+
+const text = (t: string) => JSON.stringify([{ type: "text", text: t }]);
+
+beforeEach(() => {
+  received.length = 0;
+  getDb().delete(messages).run();
+  getDb().delete(conversations).run();
+  const now = Date.now();
+  getDb()
+    .insert(conversations)
+    .values({
+      id: CONV_ID,
+      title: "message-deleted hook",
+      createdAt: now,
+      updatedAt: now,
+      source: "test",
+      conversationType: "standard",
+    })
+    .run();
+});
+
+describe("message-deleted hook dispatch", () => {
+  test("deleteMessageById dispatches once with the row's position", async () => {
+    await addMessage(CONV_ID, "user", text("hello"));
+    const reply = await addMessage(CONV_ID, "assistant", text("hi"));
+    const replyCreatedAt = getMessages(CONV_ID).find(
+      (m) => m.id === reply.id,
+    )!.createdAt;
+
+    deleteMessageById(reply.id);
+    await waitForCalls(1);
+
+    expect(received).toEqual([
+      {
+        conversationId: CONV_ID,
+        messageId: reply.id,
+        createdAt: replyCreatedAt,
+      },
+    ]);
+  });
+
+  test("deleteLastExchange dispatches for every row of the undone tail", async () => {
+    await addMessage(CONV_ID, "user", text("first"));
+    await addMessage(CONV_ID, "assistant", text("one"));
+    const user2 = await addMessage(CONV_ID, "user", text("second"));
+    const reply2 = await addMessage(CONV_ID, "assistant", text("two"));
+    const byId = new Map(getMessages(CONV_ID).map((m) => [m.id, m.createdAt]));
+
+    expect(deleteLastExchange(CONV_ID)).toBe(2);
+    await waitForCalls(2);
+
+    expect([...received].sort((a, b) => a.createdAt - b.createdAt)).toEqual([
+      {
+        conversationId: CONV_ID,
+        messageId: user2.id,
+        createdAt: byId.get(user2.id)!,
+      },
+      {
+        conversationId: CONV_ID,
+        messageId: reply2.id,
+        createdAt: byId.get(reply2.id)!,
+      },
+    ]);
+  });
+
+  test("a delete of a missing row dispatches nothing", async () => {
+    deleteMessageById("no-such-row");
+    await Bun.sleep(50);
+
+    expect(received).toEqual([]);
+  });
+});

package/src/__tests__/messages-after-tiebreaker.test.ts

@@ -1,11 +1,14 @@
 import { beforeEach, describe, expect, test } from "bun:test";
 
+import { eq } from "drizzle-orm";
+
 import {
   countMessagesAfter,
   getMessagesAfter,
 } from "../persistence/conversation-crud.js";
 import { getDb } from "../persistence/db-connection.js";
 import { initializeDb } from "../persistence/db-init.js";
+import { resolveMessagesAfterBound } from "../persistence/message-cursor.js";
 import { conversations, messages } from "../persistence/schema/index.js";
 
 await initializeDb();
@@ -113,3 +116,91 @@ describe("countMessagesAfter / getMessagesAfter — millisecond-collision tie-br
     expect(getMessagesAfter(CONV_ID, "")).toHaveLength(2);
   });
 });
+
+describe("countMessagesAfter / getMessagesAfter: a cursor survives its row's deletion", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("a cursor carrying createdAt keeps bounding the read after its row is deleted", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    // The row the cursor points at: a reply the user then regenerates.
+    insertMessage("b", ts + 1);
+    insertMessage("c", ts + 2);
+    getDb().delete(messages).where(eq(messages.id, "b")).run();
+    // The regenerated reply.
+    insertMessage("d", ts + 3);
+
+    const cursor = { id: "b", createdAt: ts + 1 };
+    expect(countMessagesAfter(CONV_ID, cursor)).toBe(2);
+    expect(getMessagesAfter(CONV_ID, cursor).map((m) => m.id)).toEqual([
+      "c",
+      "d",
+    ]);
+  });
+
+  test("a cursor without createdAt keeps the conservative id-only semantics once its row is gone", () => {
+    insertMessage("a", 1_700_000_000_000);
+
+    const cursor = { id: "nonexistent", createdAt: null };
+    expect(countMessagesAfter(CONV_ID, cursor)).toBe(0);
+    expect(getMessagesAfter(CONV_ID, cursor)).toEqual([]);
+  });
+
+  test("the live row wins over the timestamp the cursor carries", () => {
+    const ts = 1_700_000_000_000;
+    insertMessage("a", ts);
+    insertMessage("b", ts + 10);
+
+    // A stale cursor timestamp must not pull processed rows back in, nor
+    // hide unprocessed ones, while the row itself can still be read.
+    expect(countMessagesAfter(CONV_ID, { id: "b", createdAt: ts - 100 })).toBe(
+      0,
+    );
+    expect(countMessagesAfter(CONV_ID, { id: "a", createdAt: ts + 999 })).toBe(
+      1,
+    );
+  });
+
+  test("a cursor with an empty id reads everything, like null and the empty string", () => {
+    insertMessage("a", 1_700_000_000_000);
+
+    expect(countMessagesAfter(CONV_ID, { id: "", createdAt: 5 })).toBe(1);
+    expect(getMessagesAfter(CONV_ID, { id: "", createdAt: 5 })).toHaveLength(1);
+  });
+});
+
+describe("resolveMessagesAfterBound", () => {
+  beforeEach(() => {
+    clearDb();
+    seedConversation();
+  });
+
+  test("resolves the unbounded, live-row, stored-timestamp, and vanished cases", () => {
+    insertMessage("a", 1_000);
+
+    expect(resolveMessagesAfterBound(null)).toEqual({ kind: "all" });
+    expect(resolveMessagesAfterBound("")).toEqual({ kind: "all" });
+    expect(resolveMessagesAfterBound({ id: "", createdAt: 3 })).toEqual({
+      kind: "all",
+    });
+    expect(resolveMessagesAfterBound("a")).toEqual({
+      kind: "after",
+      bound: { createdAt: 1_000, id: "a" },
+    });
+    expect(resolveMessagesAfterBound({ id: "a", createdAt: 99 })).toEqual({
+      kind: "after",
+      bound: { createdAt: 1_000, id: "a" },
+    });
+    expect(resolveMessagesAfterBound("gone")).toEqual({ kind: "vanished" });
+    expect(resolveMessagesAfterBound({ id: "gone", createdAt: null })).toEqual({
+      kind: "vanished",
+    });
+    expect(resolveMessagesAfterBound({ id: "gone", createdAt: 7 })).toEqual({
+      kind: "after",
+      bound: { createdAt: 7, id: "gone" },
+    });
+  });
+});

package/src/__tests__/messages-read-boundary-guard.test.ts

@@ -52,7 +52,7 @@ const BASELINE: Readonly<Record<string, number>> = {
   "src/plugins/defaults/memory/context-search/sources/conversations.ts": 1,
   "src/plugins/defaults/memory/graph/image-ref-utils.ts": 1,
   "src/plugins/defaults/memory/indexer.ts": 2,
-  "src/plugins/defaults/memory/memory-retrospective-accounting.ts": 4,
+  "src/plugins/defaults/memory/memory-retrospective-accounting.ts": 2,
   "src/plugins/defaults/memory/substrate/sweep-job.ts": 1,
   "src/plugins/defaults/memory/v1/graph/extraction.ts": 3,
   "src/plugins/defaults/memory/v1/job-handlers/backfill.ts": 1,