@vellumai/assistant 0.8.1 → 0.8.3

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

@@ -0,0 +1,483 @@
+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,
+  getMessageRoleStatsByConversation,
+  listConversations,
+  listConversationsBySource,
+} 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);
+  });
+});
+
+describe("listConversationsBySource", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  test("returns only conversations whose source matches exactly", () => {
+    createConversation({
+      title: "consol-1",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({
+      title: "consol-2",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "heartbeat-1", source: "heartbeat" });
+    createConversation({ title: "user-1", source: "user" });
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(2);
+    expect(results.map((r) => r.title).sort()).toEqual([
+      "consol-1",
+      "consol-2",
+    ]);
+  });
+
+  test("orders by createdAt descending", () => {
+    const a = createConversation({
+      title: "a",
+      source: "memory_v2_consolidation",
+    });
+    const b = createConversation({
+      title: "b",
+      source: "memory_v2_consolidation",
+    });
+    const c = createConversation({
+      title: "c",
+      source: "memory_v2_consolidation",
+    });
+    // Force distinct createdAt regardless of ms-clock granularity.
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 1000, a.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 3000, b.id);
+    rawRun("UPDATE conversations SET created_at = ? WHERE id = ?", 2000, c.id);
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results.map((r) => r.id)).toEqual([b.id, c.id, a.id]);
+  });
+
+  test("honors the limit parameter", () => {
+    for (let i = 0; i < 5; i++) {
+      createConversation({
+        title: `consol-${i}`,
+        source: "memory_v2_consolidation",
+      });
+    }
+
+    const results = listConversationsBySource("memory_v2_consolidation", 3);
+
+    expect(results).toHaveLength(3);
+  });
+
+  test("includes archived rows by default", () => {
+    const conv = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      conv.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.archivedAt).not.toBeNull();
+  });
+
+  test("excludes archived rows when includeArchived is false", () => {
+    const archived = createConversation({
+      title: "archived",
+      source: "memory_v2_consolidation",
+    });
+    createConversation({ title: "live", source: "memory_v2_consolidation" });
+    rawRun(
+      "UPDATE conversations SET archived_at = ? WHERE id = ?",
+      Date.now(),
+      archived.id,
+    );
+
+    const results = listConversationsBySource("memory_v2_consolidation", 20, {
+      includeArchived: false,
+    });
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("live");
+  });
+
+  test("does not apply the subagent-exclusion that listConversations does", () => {
+    // The defensive `source != 'subagent'` carve-out in listConversations is
+    // a foreground/background bucketing concern. A caller asking for the
+    // exact `subagent` source via this query gets exactly that.
+    createConversation({ title: "sub-1", source: "subagent" });
+
+    const results = listConversationsBySource("subagent");
+
+    expect(results).toHaveLength(1);
+    expect(results[0]!.title).toBe("sub-1");
+  });
+});
+
+describe("getMessageRoleStatsByConversation", () => {
+  beforeEach(() => {
+    resetTables();
+  });
+
+  function insertMessage(
+    conversationId: string,
+    role: string,
+    createdAt: number,
+  ): void {
+    rawRun(
+      "INSERT INTO messages (id, conversation_id, role, content, created_at) VALUES (?, ?, ?, ?, ?)",
+      `msg-${conversationId}-${role}-${createdAt}`,
+      conversationId,
+      role,
+      "x",
+      createdAt,
+    );
+  }
+
+  test("returns empty map for empty input", () => {
+    const result = getMessageRoleStatsByConversation([]);
+    expect(result.size).toBe(0);
+  });
+
+  test("returns empty map when conversations exist but no matching role", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(0);
+  });
+
+  test("counts assistant messages and returns max createdAt", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(a.id, "assistant", 2500);
+    insertMessage(a.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.get(a.id)).toEqual({ count: 3, lastAt: 2500 });
+  });
+
+  test("does not count messages from other roles", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "system", 1500);
+    insertMessage(a.id, "assistant", 3000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.get(a.id)).toEqual({ count: 1, lastAt: 3000 });
+  });
+
+  test("scopes to the supplied conversation ids", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(b.id, "assistant", 2000);
+
+    const result = getMessageRoleStatsByConversation([a.id], "assistant");
+
+    expect(result.size).toBe(1);
+    expect(result.has(a.id)).toBe(true);
+    expect(result.has(b.id)).toBe(false);
+  });
+
+  test("aggregates per-conversation across many ids in a single query", () => {
+    const a = createConversation("a");
+    const b = createConversation("b");
+    const c = createConversation("c");
+    insertMessage(a.id, "assistant", 1000);
+    insertMessage(a.id, "assistant", 1500);
+    insertMessage(b.id, "assistant", 2000);
+    // c has no assistant messages → absent from the result.
+
+    const result = getMessageRoleStatsByConversation(
+      [a.id, b.id, c.id],
+      "assistant",
+    );
+
+    expect(result.size).toBe(2);
+    expect(result.get(a.id)).toEqual({ count: 2, lastAt: 1500 });
+    expect(result.get(b.id)).toEqual({ count: 1, lastAt: 2000 });
+    expect(result.has(c.id)).toBe(false);
+  });
+
+  test("role parameter selects the counted role (defaults to assistant)", () => {
+    const a = createConversation("a");
+    insertMessage(a.id, "user", 1000);
+    insertMessage(a.id, "user", 2000);
+    insertMessage(a.id, "assistant", 1500);
+
+    const assistants = getMessageRoleStatsByConversation([a.id]);
+    expect(assistants.get(a.id)).toEqual({ count: 1, lastAt: 1500 });
+
+    const users = getMessageRoleStatsByConversation([a.id], "user");
+    expect(users.get(a.id)).toEqual({ count: 2, lastAt: 2000 });
+  });
+});

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");
+  });
+});

package/src/memory/__tests__/memory-retrospective-enqueue.test.ts

@@ -11,26 +11,12 @@ mock.module("../../util/logger.js", () => ({
 // Mock state — reset between tests.
 // ---------------------------------------------------------------------------
 
-let flagEnabled = true;
 let sourceTag: string | null = null;
-let getConfigThrows = false;
 const upsertCalls: Array<{
   payload: { conversationId: string };
   runAfter: number;
 }> = [];
 
-mock.module("../../config/loader.js", () => ({
-  getConfig: () => {
-    if (getConfigThrows) throw new Error("boom");
-    return {};
-  },
-}));
-
-mock.module("../../config/assistant-feature-flags.js", () => ({
-  isAssistantFeatureFlagEnabled: (_key: string, _config: unknown) =>
-    flagEnabled,
-}));
-
 mock.module("../conversation-crud.js", () => ({
   getConversationSource: (_id: string) => sourceTag,
 }));
@@ -59,26 +45,11 @@ import {
 
 describe("enqueueMemoryRetrospectiveIfEnabled", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
-  test("flag off — no upsert for any trigger", () => {
-    flagEnabled = false;
-    for (const trigger of [
-      "interval",
-      "message_count",
-      "compaction",
-      "lifecycle",
-    ] as const) {
-      enqueueMemoryRetrospectiveIfEnabled({ conversationId: "c1", trigger });
-    }
-    expect(upsertCalls).toHaveLength(0);
-  });
-
-  test("flag on, standard source — interval trigger enqueues with runAfter ≈ now", () => {
+  test("standard source — interval trigger enqueues with runAfter ≈ now", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveIfEnabled({
       conversationId: "c1",
@@ -113,17 +84,6 @@ describe("enqueueMemoryRetrospectiveIfEnabled", () => {
     });
     expect(upsertCalls).toHaveLength(0);
   });
-
-  test("getConfig throws — no enqueue, no propagation", () => {
-    getConfigThrows = true;
-    expect(() =>
-      enqueueMemoryRetrospectiveIfEnabled({
-        conversationId: "c1",
-        trigger: "interval",
-      }),
-    ).not.toThrow();
-    expect(upsertCalls).toHaveLength(0);
-  });
 });
 
 describe("isMemoryRetrospectiveConversation", () => {
@@ -149,9 +109,7 @@ describe("isMemoryRetrospectiveConversation", () => {
 
 describe("enqueueMemoryRetrospectiveOnCompaction", () => {
   beforeEach(() => {
-    flagEnabled = true;
     sourceTag = null;
-    getConfigThrows = false;
     upsertCalls.length = 0;
   });
 
@@ -162,16 +120,10 @@ describe("enqueueMemoryRetrospectiveOnCompaction", () => {
     expect(upsertCalls).toHaveLength(0);
   });
 
-  test("guardian trust + flag on — enqueues with compaction debounce", () => {
+  test("guardian trust — enqueues with compaction debounce", () => {
     const before = Date.now();
     enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
     expect(upsertCalls).toHaveLength(1);
     expect(upsertCalls[0]!.runAfter).toBeGreaterThan(before + 100);
   });
-
-  test("guardian trust + flag off — no enqueue", () => {
-    flagEnabled = false;
-    enqueueMemoryRetrospectiveOnCompaction("c1", "guardian");
-    expect(upsertCalls).toHaveLength(0);
-  });
 });