@vellumai/assistant 0.8.1 → 0.8.2

package/src/memory/__tests__/bookmark-crud.test.ts

@@ -93,17 +93,13 @@ describe("bookmark-crud", () => {
       messageId: "msg-1",
     });
 
-    const first = createBookmark(db, {
-      messageId: "msg-1",
-      conversationId: "conv-1",
-    });
-    const second = createBookmark(db, {
-      messageId: "msg-1",
-      conversationId: "conv-1",
-    });
+    const first = createBookmark(db, { messageId: "msg-1" });
+    const second = createBookmark(db, { messageId: "msg-1" });
 
-    expect(second.id).toBe(first.id);
-    expect(second.createdAt).toBe(first.createdAt);
+    expect(first.inserted).toBe(true);
+    expect(second.inserted).toBe(false);
+    expect(second.bookmark.id).toBe(first.bookmark.id);
+    expect(second.bookmark.createdAt).toBe(first.bookmark.createdAt);
 
     const all = listBookmarks(db);
     expect(all.length).toBe(1);
@@ -119,11 +115,10 @@ describe("bookmark-crud", () => {
       messageRole: "assistant",
     });
 
-    const summary = createBookmark(db, {
-      messageId: "msg-summary",
-      conversationId: "conv-summary",
-    });
+    const result = createBookmark(db, { messageId: "msg-summary" });
 
+    expect(result.inserted).toBe(true);
+    const summary = result.bookmark;
     expect(summary.conversationTitle).toBe("Title goes here");
     expect(summary.messagePreview).toBe("summary body");
     expect(summary.messageRole).toBe("assistant");
@@ -179,14 +174,8 @@ describe("bookmark-crud", () => {
       conversationId: "conv-drop",
       messageId: "msg-drop",
     });
-    createBookmark(db, {
-      messageId: "msg-keep",
-      conversationId: "conv-keep",
-    });
-    createBookmark(db, {
-      messageId: "msg-drop",
-      conversationId: "conv-drop",
-    });
+    createBookmark(db, { messageId: "msg-keep" });
+    createBookmark(db, { messageId: "msg-drop" });
     expect(listBookmarks(db).length).toBe(2);
 
     // Deleting the parent conversation cascades through messages → bookmarks.
@@ -203,7 +192,7 @@ describe("bookmark-crud", () => {
       conversationId: "conv-d",
       messageId: "msg-d",
     });
-    createBookmark(db, { messageId: "msg-d", conversationId: "conv-d" });
+    createBookmark(db, { messageId: "msg-d" });
     expect(listBookmarks(db).length).toBe(1);
 
     expect(deleteBookmarkByMessageId(db, "msg-d")).toBe(true);
@@ -223,9 +212,8 @@ describe("bookmark-crud", () => {
       messageRole: "user",
     });
 
-    const summary = createBookmark(db, {
+    const { bookmark: summary } = createBookmark(db, {
       messageId: "msg-blocks",
-      conversationId: "conv-blocks",
     });
 
     // Without the decode step, this would render as the raw JSON literal
@@ -248,11 +236,29 @@ describe("bookmark-crud", () => {
       messageRole: "assistant",
     });
 
-    const summary = createBookmark(db, {
+    const { bookmark: summary } = createBookmark(db, {
       messageId: "msg-multi",
-      conversationId: "conv-multi",
     });
 
     expect(summary.messagePreview).toBe("first paragraph\nsecond paragraph");
   });
+
+  test("createBookmark derives conversationId from the message row", () => {
+    const { db, raw } = setupDb();
+    seedConversationAndMessage(raw, {
+      conversationId: "conv-real",
+      messageId: "msg-x",
+    });
+
+    const { bookmark: summary } = createBookmark(db, { messageId: "msg-x" });
+    expect(summary.conversationId).toBe("conv-real");
+    expect(listBookmarks(db)[0]?.conversationId).toBe("conv-real");
+  });
+
+  test("createBookmark throws when the message id does not exist", () => {
+    const { db } = setupDb();
+    expect(() => createBookmark(db, { messageId: "ghost" })).toThrow(
+      /Message ghost not found/,
+    );
+  });
 });

package/src/memory/__tests__/conversation-queries.test.ts

@@ -0,0 +1,263 @@
+import { beforeEach, describe, expect, mock, test } from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { createConversation } from "../conversation-crud.js";
+import {
+  buildExcerpt,
+  buildRecallEvidenceExcerpt,
+  countConversations,
+  listConversations,
+} from "../conversation-queries.js";
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { rawRun } from "../raw-query.js";
+import { conversations } from "../schema.js";
+
+initializeDb();
+
+function resetTables(): void {
+  const db = getDb();
+  db.run(`DELETE FROM messages`);
+  db.run(`DELETE FROM conversations`);
+}
+
+function setConversationType(conversationId: string, type: string): void {
+  const db = getDb();
+  db.update(conversations)
+    .set({ conversationType: type })
+    .where(eq(conversations.id, conversationId))
+    .run();
+}
+
+describe("buildExcerpt", () => {
+  test("does not expose external_content tags for legacy plain-string rows", () => {
+    const excerpt = buildExcerpt(
+      '<external_content source="slack">\nSearchable Slack text\n</external_content>',
+      "external_content",
+    );
+
+    expect(excerpt).toBe("Searchable Slack text");
+    expect(excerpt).not.toContain("<external_content");
+    expect(excerpt).not.toContain("</external_content>");
+  });
+
+  test("does not expose external_content tags for legacy text block rows", () => {
+    const excerpt = buildExcerpt(
+      JSON.stringify([
+        {
+          type: "text",
+          text: '<external_content source="slack">\nSearchable block text\n</external_content>',
+        },
+      ]),
+      "external_content",
+    );
+
+    expect(excerpt).toBe("Searchable block text");
+    expect(excerpt).not.toContain("<external_content");
+    expect(excerpt).not.toContain("</external_content>");
+  });
+});
+
+describe("buildRecallEvidenceExcerpt", () => {
+  test("preserves external_content boundaries for legacy plain-string rows", () => {
+    const excerpt = buildRecallEvidenceExcerpt(
+      '<external_content source="slack" origin="@alice">\nSearchable Slack text\n</external_content>',
+      "Slack",
+    );
+
+    expect(excerpt).toBe(
+      '<external_content source="slack" origin="@alice">\nSearchable Slack text\n</external_content>',
+    );
+  });
+
+  test("preserves external_content boundaries for legacy text block rows", () => {
+    const excerpt = buildRecallEvidenceExcerpt(
+      JSON.stringify([
+        {
+          type: "text",
+          text: '<external_content source="slack">\nSearchable block text\n</external_content>',
+        },
+      ]),
+      "block",
+    );
+
+    expect(excerpt).toBe(
+      '<external_content source="slack">\nSearchable block text\n</external_content>',
+    );
+  });
+
+  test("preserves external_content boundaries when joined with other text blocks", () => {
+    const excerpt = buildRecallEvidenceExcerpt(
+      JSON.stringify([
+        {
+          type: "text",
+          text: '<external_content source="slack">\nSearchable block text\n</external_content>',
+        },
+        {
+          type: "text",
+          text: "Local follow-up text.",
+        },
+      ]),
+      "block",
+    );
+
+    expect(excerpt).toBe(
+      '<external_content source="slack">\nSearchable block text\n</external_content> Local follow-up text.',
+    );
+  });
+
+  test("does not unwrap malformed or mixed external_content text", () => {
+    const malformed =
+      '<external_content source="slack">Malformed Slack text</external_content>';
+    const mixed =
+      'prefix <external_content source="slack">\nMixed Slack text\n</external_content>';
+
+    expect(buildRecallEvidenceExcerpt(malformed, "Slack")).toBe(malformed);
+    expect(buildRecallEvidenceExcerpt(mixed, "Slack")).toBe(
+      'prefix <external_content source="slack"> Mixed Slack text </external_content>',
+    );
+  });
+});
+
+describe("countConversations", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("excludes 'private', 'background', and 'scheduled' rows from the foreground count", () => {
+    createConversation("foreground-1");
+    createConversation("foreground-2");
+
+    const priv = createConversation("private-1");
+    setConversationType(priv.id, "private");
+
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    expect(countConversations()).toBe(2);
+  });
+
+  test("background-only count excludes private rows", () => {
+    createConversation("foreground-1");
+    createConversation({ title: "bg-1", conversationType: "background" });
+    createConversation({ title: "sched-1", conversationType: "scheduled" });
+
+    const priv = createConversation("private-1");
+    setConversationType(priv.id, "private");
+
+    expect(countConversations(true)).toBe(2);
+  });
+
+  test("includes standard conversations with group_id system:background in background count", () => {
+    // GIVEN a standard conversation routed to system:background (e.g. heartbeat)
+    createConversation({
+      title: "heartbeat-1",
+      source: "heartbeat",
+      groupId: "system:background",
+    });
+
+    // AND a regular foreground conversation
+    createConversation("foreground-1");
+
+    // WHEN counting background conversations
+    const bgCount = countConversations(true);
+
+    // THEN the heartbeat conversation is included
+    expect(bgCount).toBe(1);
+
+    // AND excluded from the foreground count
+    expect(countConversations(false)).toBe(1);
+  });
+
+  test("excludes standard conversations with group_id system:background from foreground count", () => {
+    // GIVEN two foreground conversations and one heartbeat
+    createConversation("foreground-1");
+    createConversation("foreground-2");
+    createConversation({
+      title: "heartbeat-1",
+      source: "heartbeat",
+      groupId: "system:background",
+    });
+
+    // WHEN counting foreground conversations
+    // THEN the heartbeat is excluded
+    expect(countConversations(false)).toBe(2);
+  });
+});
+
+describe("listConversations", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("background fetch includes conversations with group_id system:background regardless of conversationType", () => {
+    // GIVEN a heartbeat conversation (conversationType standard, group_id system:background)
+    createConversation({
+      title: "heartbeat-1",
+      source: "heartbeat",
+      groupId: "system:background",
+    });
+
+    // AND a real background conversation
+    createConversation({ title: "bg-1", conversationType: "background" });
+
+    // AND a foreground conversation
+    createConversation("foreground-1");
+
+    // WHEN listing background conversations
+    const bgList = listConversations(100, true);
+
+    // THEN both background and heartbeat conversations are returned
+    expect(bgList).toHaveLength(2);
+    const titles = bgList.map((c) => c.title);
+    expect(titles).toContain("heartbeat-1");
+    expect(titles).toContain("bg-1");
+  });
+
+  test("foreground fetch excludes conversations with group_id system:background", () => {
+    // GIVEN a heartbeat conversation (conversationType standard, group_id system:background)
+    createConversation({
+      title: "heartbeat-1",
+      source: "heartbeat",
+      groupId: "system:background",
+    });
+
+    // AND a foreground conversation
+    createConversation("foreground-1");
+
+    // WHEN listing foreground conversations
+    const fgList = listConversations(100, false);
+
+    // THEN only the foreground conversation is returned
+    expect(fgList).toHaveLength(1);
+    expect(fgList[0]!.title).toBe("foreground-1");
+  });
+
+  test("conversations with group_id system:scheduled are included in background fetch", () => {
+    // GIVEN a conversation with group_id system:scheduled but conversationType standard
+    const conv = createConversation("schedule-routed");
+    rawRun(
+      "UPDATE conversations SET group_id = 'system:scheduled' WHERE id = ?",
+      conv.id,
+    );
+
+    // WHEN listing background conversations
+    const bgList = listConversations(100, true);
+
+    // THEN it appears in the background list
+    expect(bgList).toHaveLength(1);
+    expect(bgList[0]!.title).toBe("schedule-routed");
+
+    // AND not in the foreground list
+    const fgList = listConversations(100, false);
+    expect(fgList).toHaveLength(0);
+  });
+});

package/src/memory/__tests__/jobs-worker-v2-graph-trigger-embed.test.ts

@@ -0,0 +1,113 @@
+/**
+ * Regression: `graph_trigger_embed` must NOT be short-circuited when
+ * `memory.v2.enabled` is true. The handler `embedGraphTriggerJob` writes
+ * `conditionEmbedding` to SQLite and never touches the v1 Qdrant client, so
+ * including it in `V1_QDRANT_JOB_TYPES` would leave semantic triggers
+ * permanently unembedded under v2 and break `evaluateSemanticTriggers`
+ * recall.
+ */
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  beforeAll,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+import { eq } from "drizzle-orm";
+
+import { makeMockLogger } from "../../__tests__/helpers/mock-logger.js";
+import { DEFAULT_CONFIG } from "../../config/defaults.js";
+import type { AssistantConfig } from "../../config/types.js";
+
+mock.module("../../util/logger.js", () => ({
+  getLogger: () => makeMockLogger(),
+}));
+
+const TEST_CONFIG: AssistantConfig = {
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    enabled: true,
+    v2: { ...DEFAULT_CONFIG.memory.v2, enabled: true },
+  },
+};
+
+mock.module("../../config/loader.js", () => ({
+  getConfig: () => TEST_CONFIG,
+  loadConfig: () => TEST_CONFIG,
+  invalidateConfigCache: () => {},
+}));
+
+let triggerHandlerCalls = 0;
+
+mock.module("../graph/graph-search.js", () => ({
+  searchGraphNodes: async () => [],
+  embedGraphNodeDirect: async () => {},
+  embedGraphNodeJob: async (): Promise<void> => {},
+  enqueueGraphNodeEmbed: () => {},
+  embedGraphTriggerJob: async (): Promise<void> => {
+    triggerHandlerCalls += 1;
+  },
+  enqueueGraphTriggerEmbed: () => {},
+}));
+
+mock.module("../db-maintenance.js", () => ({
+  maybeRunDbMaintenance: () => {},
+}));
+
+const tmpWorkspace = mkdtempSync(
+  join(tmpdir(), "jobs-worker-v2-graph-trigger-embed-"),
+);
+const previousWorkspaceEnv = process.env.VELLUM_WORKSPACE_DIR;
+process.env.VELLUM_WORKSPACE_DIR = tmpWorkspace;
+
+import { getDb } from "../db-connection.js";
+import { initializeDb } from "../db-init.js";
+import { enqueueMemoryJob } from "../jobs-store.js";
+import { runMemoryJobsOnce } from "../jobs-worker.js";
+import { _resetQdrantBreaker } from "../qdrant-circuit-breaker.js";
+import { memoryJobs } from "../schema.js";
+
+describe("graph_trigger_embed under memory v2", () => {
+  beforeAll(() => {
+    initializeDb();
+  });
+
+  afterAll(() => {
+    if (previousWorkspaceEnv === undefined) {
+      delete process.env.VELLUM_WORKSPACE_DIR;
+    } else {
+      process.env.VELLUM_WORKSPACE_DIR = previousWorkspaceEnv;
+    }
+    rmSync(tmpWorkspace, { recursive: true, force: true });
+  });
+
+  beforeEach(() => {
+    getDb().run("DELETE FROM memory_jobs");
+    triggerHandlerCalls = 0;
+    _resetQdrantBreaker();
+  });
+
+  test("handler runs (is not short-circuited) when v2 is enabled", async () => {
+    const jobId = enqueueMemoryJob("graph_trigger_embed", {
+      triggerId: "trigger-123",
+    });
+
+    await runMemoryJobsOnce();
+
+    expect(triggerHandlerCalls).toBe(1);
+
+    const rows = getDb()
+      .select()
+      .from(memoryJobs)
+      .where(eq(memoryJobs.id, jobId))
+      .all();
+    expect(rows[0]?.status).toBe("completed");
+  });
+});