@vellumai/assistant 0.5.2 → 0.5.3

package/src/__tests__/memory-observation-archive.test.ts

@@ -0,0 +1,375 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const testDir = mkdtempSync(join(tmpdir(), "memory-observation-archive-test-"));
+const dbPath = join(testDir, "test.db");
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+import { eq } from "drizzle-orm";
+
+import {
+  computeObservationContentHash,
+  getChunkByObservationId,
+  getObservation,
+  insertObservation,
+  type InsertObservationParams,
+  insertObservations,
+} from "../memory/archive-store.js";
+import { getDb, initializeDb, rawAll, resetDb } from "../memory/db.js";
+import { claimMemoryJobs } from "../memory/jobs-store.js";
+import { conversations, memoryChunks, messages } from "../memory/schema.js";
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+function createConversation(id: string): void {
+  const db = getDb();
+  const now = Date.now();
+  db.insert(conversations)
+    .values({
+      id,
+      createdAt: now,
+      updatedAt: now,
+    })
+    .run();
+}
+
+function createMessage(id: string, conversationId: string): void {
+  const db = getDb();
+  db.insert(messages)
+    .values({
+      id,
+      conversationId,
+      role: "user",
+      content: "test message",
+      createdAt: Date.now(),
+    })
+    .run();
+}
+
+function getJobsByType(type: string) {
+  return rawAll<{
+    id: string;
+    type: string;
+    payload: string;
+    status: string;
+  }>(`SELECT id, type, payload, status FROM memory_jobs WHERE type = ?`, type);
+}
+
+// ── Setup ───────────────────────────────────────────────────────────
+
+describe("memory observation archive store", () => {
+  beforeEach(() => {
+    resetDb();
+    removeTestDbFiles();
+    initializeDb();
+  });
+
+  afterEach(() => {
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    resetDb();
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  // ── Row insertion ───────────────────────────────────────────────
+
+  describe("insertObservation", () => {
+    test("inserts observation row into memory_observations table", () => {
+      createConversation("conv-1");
+
+      const result = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user prefers dark mode",
+      });
+
+      expect(result.observationId).toBeTruthy();
+      expect(result.contentHash).toBeTruthy();
+
+      const obs = getObservation(result.observationId);
+      expect(obs).toBeDefined();
+      expect(obs!.conversationId).toBe("conv-1");
+      expect(obs!.role).toBe("user");
+      expect(obs!.content).toBe("The user prefers dark mode");
+      expect(obs!.modality).toBe("text");
+      expect(obs!.scopeId).toBe("default");
+    });
+
+    test("inserts associated chunk with correct content hash", () => {
+      createConversation("conv-1");
+
+      const result = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user lives in NYC",
+      });
+
+      expect(result.chunkId).toBeTruthy();
+
+      const chunk = getChunkByObservationId(result.observationId);
+      expect(chunk).toBeDefined();
+      expect(chunk!.content).toBe("The user lives in NYC");
+      expect(chunk!.contentHash).toBe(result.contentHash);
+      expect(chunk!.tokenEstimate).toBeGreaterThan(0);
+      expect(chunk!.scopeId).toBe("default");
+    });
+
+    test("respects optional params: scopeId, modality, source, messageId", () => {
+      createConversation("conv-1");
+      createMessage("msg-1", "conv-1");
+
+      const result = insertObservation({
+        conversationId: "conv-1",
+        messageId: "msg-1",
+        role: "assistant",
+        content: "Voice observation about weather",
+        scopeId: "custom-scope",
+        modality: "voice",
+        source: "phone",
+      });
+
+      const obs = getObservation(result.observationId);
+      expect(obs).toBeDefined();
+      expect(obs!.messageId).toBe("msg-1");
+      expect(obs!.scopeId).toBe("custom-scope");
+      expect(obs!.modality).toBe("voice");
+      expect(obs!.source).toBe("phone");
+    });
+
+    test("does not touch legacy memory tables", () => {
+      createConversation("conv-1");
+
+      insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "A fact about the user",
+      });
+
+      // Verify no rows in legacy memory_segments or memory_items
+      const segments = rawAll<{ id: string }>(`SELECT id FROM memory_segments`);
+      const items = rawAll<{ id: string }>(`SELECT id FROM memory_items`);
+      expect(segments).toHaveLength(0);
+      expect(items).toHaveLength(0);
+    });
+  });
+
+  // ── Content hash idempotency ──────────────────────────────────
+
+  describe("content hash idempotency", () => {
+    test("duplicate content in same scope does not create a second chunk", () => {
+      createConversation("conv-1");
+
+      const result1 = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user likes cats",
+      });
+
+      const result2 = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user likes cats",
+      });
+
+      // Both observations should exist
+      expect(getObservation(result1.observationId)).toBeDefined();
+      expect(getObservation(result2.observationId)).toBeDefined();
+
+      // First creates a chunk, second is deduplicated
+      expect(result1.chunkId).toBeTruthy();
+      expect(result2.chunkId).toBeNull();
+
+      // Only one chunk row should exist
+      const db = getDb();
+      const chunks = db
+        .select()
+        .from(memoryChunks)
+        .where(eq(memoryChunks.scopeId, "default"))
+        .all();
+      expect(chunks).toHaveLength(1);
+    });
+
+    test("same content in different scopes creates separate chunks", () => {
+      createConversation("conv-1");
+
+      const result1 = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user likes dogs",
+        scopeId: "scope-a",
+      });
+
+      const result2 = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "The user likes dogs",
+        scopeId: "scope-b",
+      });
+
+      expect(result1.chunkId).toBeTruthy();
+      expect(result2.chunkId).toBeTruthy();
+      expect(result1.chunkId).not.toBe(result2.chunkId);
+    });
+
+    test("content hashes are deterministic", () => {
+      const hash1 = computeObservationContentHash("default", "Hello world");
+      const hash2 = computeObservationContentHash("default", "Hello world");
+      expect(hash1).toBe(hash2);
+
+      // Different scope produces different hash
+      const hash3 = computeObservationContentHash("other", "Hello world");
+      expect(hash1).not.toBe(hash3);
+    });
+  });
+
+  // ── Embedding job dispatch ────────────────────────────────────
+
+  describe("embedding job dispatch", () => {
+    test("enqueues embed_observation job when new chunk is created", () => {
+      createConversation("conv-1");
+
+      const result = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "User prefers TypeScript",
+      });
+
+      expect(result.embeddingJobId).toBeTruthy();
+
+      const jobs = getJobsByType("embed_observation");
+      expect(jobs).toHaveLength(1);
+      expect(jobs[0].status).toBe("pending");
+
+      const payload = JSON.parse(jobs[0].payload);
+      expect(payload.observationId).toBe(result.observationId);
+      expect(payload.chunkId).toBe(result.chunkId);
+    });
+
+    test("does not enqueue embed job when chunk is deduplicated", () => {
+      createConversation("conv-1");
+
+      // First insert creates a chunk and job
+      insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "User prefers Python",
+      });
+
+      // Second insert with same content should not create another job
+      const result2 = insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "User prefers Python",
+      });
+
+      expect(result2.embeddingJobId).toBeNull();
+
+      const jobs = getJobsByType("embed_observation");
+      expect(jobs).toHaveLength(1); // Only from the first insert
+    });
+
+    test("embed_observation jobs are claimable by the worker", () => {
+      createConversation("conv-1");
+
+      insertObservation({
+        conversationId: "conv-1",
+        role: "user",
+        content: "Claimable observation",
+      });
+
+      const claimed = claimMemoryJobs(10);
+      const embedJobs = claimed.filter((j) => j.type === "embed_observation");
+      expect(embedJobs).toHaveLength(1);
+      expect(embedJobs[0].status).toBe("running");
+      expect(embedJobs[0].payload.observationId).toBeTruthy();
+      expect(embedJobs[0].payload.chunkId).toBeTruthy();
+    });
+  });
+
+  // ── Batch insertion ───────────────────────────────────────────
+
+  describe("insertObservations (batch)", () => {
+    test("inserts multiple observations atomically", () => {
+      createConversation("conv-1");
+
+      const params: InsertObservationParams[] = [
+        { conversationId: "conv-1", role: "user", content: "Fact A" },
+        { conversationId: "conv-1", role: "user", content: "Fact B" },
+        { conversationId: "conv-1", role: "assistant", content: "Fact C" },
+      ];
+
+      const results = insertObservations(params);
+      expect(results).toHaveLength(3);
+
+      // All observations should exist
+      for (const result of results) {
+        expect(getObservation(result.observationId)).toBeDefined();
+      }
+
+      // All should have chunks (different content)
+      for (const result of results) {
+        expect(result.chunkId).toBeTruthy();
+      }
+
+      // All should have embedding jobs
+      const jobs = getJobsByType("embed_observation");
+      expect(jobs).toHaveLength(3);
+    });
+
+    test("batch handles content hash dedup within the batch", () => {
+      createConversation("conv-1");
+
+      const params: InsertObservationParams[] = [
+        { conversationId: "conv-1", role: "user", content: "Same content" },
+        { conversationId: "conv-1", role: "user", content: "Same content" },
+      ];
+
+      const results = insertObservations(params);
+      expect(results).toHaveLength(2);
+
+      // First creates a chunk, second is deduplicated
+      expect(results[0].chunkId).toBeTruthy();
+      expect(results[1].chunkId).toBeNull();
+
+      // Only one embedding job
+      const jobs = getJobsByType("embed_observation");
+      expect(jobs).toHaveLength(1);
+    });
+  });
+});

package/src/__tests__/memory-observation-dual-write.test.ts

@@ -0,0 +1,318 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  afterAll,
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  test,
+} from "bun:test";
+
+const testDir = mkdtempSync(
+  join(tmpdir(), "memory-observation-dual-write-test-"),
+);
+const dbPath = join(testDir, "test.db");
+
+mock.module("../util/platform.js", () => ({
+  getDataDir: () => testDir,
+  getRootDir: () => join(testDir, ".vellum"),
+  getWorkspaceDir: () => join(testDir, ".vellum", "workspace"),
+  getConversationsDir: () =>
+    join(testDir, ".vellum", "workspace", "conversations"),
+  isMacOS: () => process.platform === "darwin",
+  isLinux: () => process.platform === "linux",
+  isWindows: () => process.platform === "win32",
+  getPidPath: () => join(testDir, "test.pid"),
+  getDbPath: () => dbPath,
+  getLogPath: () => join(testDir, "test.log"),
+  ensureDataDir: () => {},
+}));
+
+mock.module("../util/logger.js", () => ({
+  getLogger: () =>
+    new Proxy({} as Record<string, unknown>, {
+      get: () => () => {},
+    }),
+}));
+
+// Stub the local embedding backend so the real ONNX model never loads.
+mock.module("../memory/embedding-local.js", () => ({
+  LocalEmbeddingBackend: class {
+    readonly provider = "local" as const;
+    readonly model: string;
+    constructor(model: string) {
+      this.model = model;
+    }
+    async embed(texts: string[]): Promise<number[][]> {
+      return texts.map(() => new Array(384).fill(0));
+    }
+  },
+}));
+
+// Mock Qdrant client so semantic search returns empty results.
+mock.module("../memory/qdrant-client.js", () => ({
+  getQdrantClient: () => ({
+    searchWithFilter: async () => [],
+    hybridSearch: async () => [],
+    upsertPoints: async () => {},
+    deletePoints: async () => {},
+  }),
+  initQdrantClient: () => {},
+}));
+
+import { DEFAULT_CONFIG } from "../config/defaults.js";
+
+// Enable memory but disable LLM extraction and summarization.
+const TEST_CONFIG = {
+  ...DEFAULT_CONFIG,
+  memory: {
+    ...DEFAULT_CONFIG.memory,
+    enabled: true,
+    extraction: {
+      ...DEFAULT_CONFIG.memory.extraction,
+      useLLM: false,
+    },
+    summarization: {
+      ...DEFAULT_CONFIG.memory.summarization,
+      useLLM: false,
+    },
+  },
+};
+
+mock.module("../config/loader.js", () => ({
+  loadConfig: () => TEST_CONFIG,
+  getConfig: () => TEST_CONFIG,
+  invalidateConfigCache: () => {},
+}));
+
+import { eq } from "drizzle-orm";
+
+import { getChunkByObservationId } from "../memory/archive-store.js";
+import { addMessage, createConversation } from "../memory/conversation-crud.js";
+import { getDb, initializeDb, rawAll, resetDb } from "../memory/db.js";
+import { memoryObservations, memorySegments } from "../memory/schema.js";
+
+function removeTestDbFiles(): void {
+  rmSync(dbPath, { force: true });
+  rmSync(`${dbPath}-shm`, { force: true });
+  rmSync(`${dbPath}-wal`, { force: true });
+}
+
+function getObservationsByConversation(conversationId: string) {
+  const db = getDb();
+  return db
+    .select()
+    .from(memoryObservations)
+    .where(eq(memoryObservations.conversationId, conversationId))
+    .all();
+}
+
+function getJobsByType(type: string) {
+  return rawAll<{
+    id: string;
+    type: string;
+    payload: string;
+    status: string;
+  }>(`SELECT id, type, payload, status FROM memory_jobs WHERE type = ?`, type);
+}
+
+// ── Setup ───────────────────────────────────────────────────────────
+
+describe("memory observation dual-write from addMessage", () => {
+  beforeEach(() => {
+    resetDb();
+    removeTestDbFiles();
+    initializeDb();
+  });
+
+  afterEach(() => {
+    resetDb();
+    removeTestDbFiles();
+  });
+
+  afterAll(() => {
+    resetDb();
+    rmSync(testDir, { recursive: true, force: true });
+  });
+
+  // ── Text-only messages ──────────────────────────────────────────
+
+  describe("text-only messages", () => {
+    test("creates an observation for a plain text user message", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "I prefer dark mode for all editors");
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      expect(observations[0].role).toBe("user");
+      expect(observations[0].content).toBe(
+        "I prefer dark mode for all editors",
+      );
+      expect(observations[0].modality).toBe("text");
+      expect(observations[0].scopeId).toBe("default");
+    });
+
+    test("creates an observation for an assistant message", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(
+        conv.id,
+        "assistant",
+        "Sure, I will use dark mode from now on.",
+      );
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      expect(observations[0].role).toBe("assistant");
+      expect(observations[0].content).toBe(
+        "Sure, I will use dark mode from now on.",
+      );
+    });
+
+    test("creates a chunk with embed_chunk job for text message", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "My favorite language is TypeScript");
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+
+      const chunk = getChunkByObservationId(observations[0].id);
+      expect(chunk).toBeDefined();
+      expect(chunk!.content).toBe("My favorite language is TypeScript");
+
+      const embedJobs = getJobsByType("embed_chunk");
+      expect(embedJobs.length).toBeGreaterThanOrEqual(1);
+      const matchingJob = embedJobs.find((j) => {
+        const payload = JSON.parse(j.payload);
+        return payload.chunkId === chunk!.id;
+      });
+      expect(matchingJob).toBeDefined();
+    });
+
+    test("links observation to the correct messageId", async () => {
+      const conv = createConversation("test-conv");
+      const msg = await addMessage(conv.id, "user", "Testing message link");
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      expect(observations[0].messageId).toBe(msg.id);
+    });
+
+    test("uses conversation memory scope for observation", async () => {
+      const conv = createConversation({
+        conversationType: "private",
+      });
+      await addMessage(conv.id, "user", "Private observation");
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      expect(observations[0].scopeId).toBe(`private:${conv.id}`);
+    });
+  });
+
+  // ── Multimodal messages ─────────────────────────────────────────
+
+  describe("multimodal messages", () => {
+    test("creates observation for message with text + image blocks", async () => {
+      const conv = createConversation("test-conv");
+      const content = JSON.stringify([
+        { type: "text", text: "Here is my screenshot" },
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: "iVBORw0KGgo=",
+          },
+        },
+      ]);
+      await addMessage(conv.id, "user", content);
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      // Text extraction produces the text portion
+      expect(observations[0].content).toContain("Here is my screenshot");
+      // Text+image = multimodal since media blocks are present
+      expect(observations[0].modality).toBe("multimodal");
+    });
+
+    test("creates observation with multimodal modality for image-only message", async () => {
+      const conv = createConversation("test-conv");
+      const content = JSON.stringify([
+        {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: "image/png",
+            data: "iVBORw0KGgo=",
+          },
+        },
+      ]);
+      await addMessage(conv.id, "user", content);
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+      expect(observations[0].modality).toBe("multimodal");
+    });
+  });
+
+  // ── Legacy indexing unchanged ───────────────────────────────────
+
+  describe("legacy indexing continues alongside dual-write", () => {
+    test("legacy memory_segments are still created for text messages", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "A fact worth remembering for memory");
+
+      // Legacy segments should exist
+      const db = getDb();
+      const segments = db
+        .select()
+        .from(memorySegments)
+        .where(eq(memorySegments.conversationId, conv.id))
+        .all();
+      expect(segments.length).toBeGreaterThanOrEqual(1);
+
+      // Observation should also exist
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(1);
+    });
+
+    test("legacy extract_items jobs are still enqueued for user messages", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "The user lives in San Francisco");
+
+      const extractJobs = getJobsByType("extract_items");
+      expect(extractJobs.length).toBeGreaterThanOrEqual(1);
+    });
+
+    test("skipping indexing skips both legacy and observation writes", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "No indexing please", undefined, {
+        skipIndexing: true,
+      });
+
+      // No legacy segments
+      const db = getDb();
+      const segments = db
+        .select()
+        .from(memorySegments)
+        .where(eq(memorySegments.conversationId, conv.id))
+        .all();
+      expect(segments).toHaveLength(0);
+
+      // No observations
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(0);
+    });
+
+    test("does not create observation for empty content messages", async () => {
+      const conv = createConversation("test-conv");
+      await addMessage(conv.id, "user", "");
+
+      const observations = getObservationsByConversation(conv.id);
+      expect(observations).toHaveLength(0);
+    });
+  });
+});