memories-lite 0.9.1 → 0.9.3

package/src/prompts/index.ts

@@ -153,15 +153,15 @@ You must strictly extract {Subject, Predicate, Object} triplets by following the
   - Extract triplets that describe facts *about the user* based on their statements, covering areas like preferences, beliefs, actions, experiences, learning, identity, work, or relationships (e.g., "I love working").
   - Apply explicit, precise, and unambiguous predicates (e.g., "owns", "is located at", "is a", "has function", "causes", etc.).
   - Determine the triplet type (e.g., "factual", "episodic", "procedural", "semantic") based on the content and meaning.
-    - "episodic" for time-based events (e.g., "I went to the park yesterday").
+    - "episodic" If a fact depends on a temporal, situational, or immediate personal context, then that fact AND ALL OF ITS sub-facts MUST be classified as episodic.
     - "procedural" for business processes (e.g., "Looking for customer John Doe address", "How to create a new contract").
     - "factual" for stable user data (except procedural that prevails).
     
   - Eliminate introductions, sub-facts, detailed repetitive elements, stylistic fillers, or vague statements. General facts always takes precedence over multiple sub-facts (signal vs noise).
   - The query intention can include specific preferences about how the Assistant should respond (e.g., "answer concisely", "explain in detail").   
-  - Compress each fact  and reason (less than 12 words).
+  - Compress each OUTPUT (fact and reason) with less than 10 words.
   - DO NOT infer personal facts from third-party informations.
-  - Treat "Assistant Answer:" as external responses from the Assistant to enrich your reasoning process about the user.
+  - Treat "**ASSISTANT**:" as responses to enrich context of your reasoning process about the USER query.
 2. Use pronoun "I" instead of "The user" in the subject of the triplet.
 3. Do not output any facts already present in section # PRE-EXISTING FACTS.
   - If you find facts already present in section # PRE-EXISTING FACTS, use field "existing" to store them.

package/src/vectorstores/lite.ts

@@ -5,6 +5,7 @@ import sqlite3 from 'sqlite3';
 import { VectorStore } from "./base";
 import { SearchFilters, VectorStoreConfig, VectorStoreResult, MemoryPayload, MemoryScoringConfig, MemoryType } from "../types";
 import { createHash } from 'crypto';
+import { existsSync } from 'fs';
 
 
 // Define interface for database rows
@@ -25,6 +26,7 @@ interface MemoryVector {
  */
 export class LiteVectorStore implements VectorStore {
   private db: sqlite3.Database;
+  private dbPath: string;
   private isSecure: boolean;
   private dimension: number;
   private currentUserId: string;
@@ -39,20 +41,21 @@ export class LiteVectorStore implements VectorStore {
     this.currentUserId = currentUserId;
     this.isSecure = config.secure || false;
     this.scoringConfig = config.scoring;
-    this.cleanupThreshold = config.recencyCleanupThreshold; // Store threshold
+    this.cleanupThreshold = config.recencyCleanupThreshold || 0.25; // (default 0.25 means 2 times the half-life  )
     config.rootPath = config.rootPath || process.cwd();
     const filename = this.isSecure ? `memories-lite-${currentUserId}.db` : `memories-lite-global.db`;
-    const dbPath = (config.rootPath == ':memory:') ? ':memory:' : path.join(config.rootPath, filename);
+    this.dbPath = (config.rootPath == ':memory:') ? ':memory:' : path.join(config.rootPath, filename);
 
     // Add error handling callback for the database connection
-    this.db = new sqlite3.Database(dbPath);
+    this.db = new sqlite3.Database(this.dbPath);
   }
 
 
   private async init() {
-    await this.run(`
-      CREATE TABLE IF NOT EXISTS vectors (
-        id TEXT PRIMARY KEY,
+    try{
+      await this.run(`
+        CREATE TABLE IF NOT EXISTS vectors (
+          id TEXT PRIMARY KEY,
         vector BLOB NOT NULL,
         payload TEXT NOT NULL
       )
@@ -64,6 +67,9 @@ export class LiteVectorStore implements VectorStore {
         user_id TEXT NOT NULL UNIQUE
       )
     `);
+    }catch(err){
+      console.log("-- DBG init error:",err);
+    }
   }
 
   private async run(sql: string, params: any[] = []): Promise<void> {
@@ -151,9 +157,12 @@ export class LiteVectorStore implements VectorStore {
     if (cachedStore) {
       Object.setPrototypeOf(cachedStore, LiteVectorStore.prototype);
       cachedStore.currentUserId = hashedUserId;
-      // Ensure scoring config and threshold are updated if config object changed
-      cachedStore.scoringConfig = config.scoring;
-      cachedStore.cleanupThreshold = config.recencyCleanupThreshold;
+
+      //
+      // if the database file does not exist, we need to reinitialize the store
+      if (cachedStore.dbPath!==':memory:' && !existsSync(cachedStore.dbPath)) {
+        return new LiteVectorStore(config, hashedUserId);
+      }
       return cachedStore;
     }
 
@@ -176,13 +185,20 @@ export class LiteVectorStore implements VectorStore {
           `Vector dimension mismatch. Expected ${this.dimension}, got ${vectors[i].length}`,
         );
       }
+
+      const payload = {...payloads[i]};
+      //
+      // case of global store (insecure)
+      if(!payload.userId){
+        throw new Error("userId is required in payload");
+      }
       //
       // remove the userId from the payload as sensitive data
-      this.isSecure && delete payloads[i].userId;
+      this.isSecure && delete payload.userId;
       const vectorBuffer = Buffer.from(new Float32Array(vectors[i]).buffer);
       await this.run(
         `INSERT OR REPLACE INTO vectors (id, vector, payload) VALUES (?, ?, ?)`,
-        [ids[i], vectorBuffer, JSON.stringify(payloads[i])],
+        [ids[i], vectorBuffer, JSON.stringify(payload)],
       );
     }
 
@@ -199,6 +215,15 @@ export class LiteVectorStore implements VectorStore {
       );
     }
 
+
+
+    if(!filters || !filters.userId){
+      throw new Error("userId is mandatory in search");
+    }
+    filters = {...filters};
+    this.isSecure && delete filters.userId;
+
+
     const results: VectorStoreResult[] = [];
     const rows = await this.all(`SELECT * FROM vectors`);
 
@@ -290,18 +315,23 @@ export class LiteVectorStore implements VectorStore {
     const rows = await this.all(`SELECT * FROM vectors`);
     const results: VectorStoreResult[] = [];
 
+    //
+    // remove the userId from the payload as sensitive data
+    filters = {...filters};
+    this.isSecure && delete filters?.userId;
+
     for (const row of rows) {
       const memoryVector: MemoryVector = {
         id: row.id,
         vector: Array.from(new Float32Array(row.vector.buffer)),
-        payload: {},
+        payload: JSON.parse(row.payload),
       };
 
       if (this.filterVector(memoryVector, filters)) {
         // load payload at the end
         results.push({
           id: memoryVector.id,
-          payload: JSON.parse(row.payload),
+          payload:memoryVector.payload,
         });
       }
     }
@@ -356,7 +386,15 @@ export class LiteVectorStore implements VectorStore {
     return Math.max(0, hybridScore);
   }
 
-  // Internal method to clean up vectors based on recency score threshold
+  /**
+   * Internal method to clean up vectors based on recency score threshold.
+   * 
+   * @param threshold - The minimum recency score required for a memory to be retained.
+   *   - Recency score is calculated using exponential decay: 1.0 means brand new, 0.5 means at half-life, 0.0 means fully decayed.
+   *   - Memories with a recency score below this threshold will be deleted (unless their half-life is infinite or zero).
+   *   - For example, a threshold of 0.25 will remove all memories whose recency score has decayed 2 times the half-life.
+   *   - Use a lower threshold to keep more old memories, or a higher threshold to keep only fresher ones.
+   */
   private async _cleanupByRecency(threshold: number): Promise<number> {
     const rows = await this.all(`SELECT id, payload FROM vectors`);
     let deletedCount = 0;

package/tests/init.mem.ts

@@ -0,0 +1,40 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import dotenv from "dotenv";
+
+dotenv.config();
+
+/**
+ * Helper to initialize MemoriesLite instance and generate a random userId.
+ * @param customPrompt Optional prompt to inject into the memory config.
+ */
+export function createTestMemory({customPrompt, dimension, rootPath, secure}:any) {
+  dimension = dimension || 768;
+  const userId =
+    Math.random().toString(36).substring(2, 15) +
+    Math.random().toString(36).substring(2, 15);
+
+  const memory = new MemoriesLite({
+    version: "v1.1",
+    disableHistory: true,
+    ...(customPrompt ? { customPrompt } : {}),
+    embedder: {
+      provider: "openai",
+      config: { dimension, apiKey: process.env.OPENAI_API_KEY!, model: "text-embedding-3-small" }
+    },
+    vectorStore: {
+      provider: "lite",
+      config: { 
+        dimension, 
+        rootPath: (rootPath || ":memory:"), 
+        secure: secure || false }
+    },
+    llm: {
+      provider: "openai",
+      config: { apiKey: process.env.OPENAI_API_KEY || "", model: "gpt-4.1-mini" }
+    },
+    historyDbPath: ":memory:"
+  });
+
+  return { memory, userId };
+} 

package/tests/memory.facts.test.ts

@@ -2,6 +2,7 @@
 import { MemoriesLite } from "../src";
 import { MemoryItem, SearchResult } from "../src/types";
 import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
 
 dotenv.config();
 
@@ -9,42 +10,11 @@ jest.setTimeout(30000); // Increase timeout to 30 seconds
 
 describe("Memory Class facts regression tests", () => {
   let memory: MemoriesLite;
-  const userId =
-    Math.random().toString(36).substring(2, 15) +
-    Math.random().toString(36).substring(2, 15);
-
-  const dimension = 768;
+  let userId: string;
 
   beforeEach(async () => {
-    // Initialize with default configuration
-    memory = new MemoriesLite({
-      version: "v1.1",
-      disableHistory: true,
-      customPrompt: "L'utilisateur travail pour une régie immobilière!",
-      embedder: {
-        provider: "openai",
-        config: {
-          dimension,
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "text-embedding-3-small",
-        },
-      },
-      vectorStore: {
-        provider: "lite",
-        config: {
-          dimension,
-          rootPath: ":memory:",
-        },
-      },
-      llm: {
-        provider: "openai",
-        config: {
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "gpt-4.1-mini",
-        },
-      },
-      historyDbPath: ":memory:", // Use in-memory SQLite for tests
-    });
+    // Initialize memory via helper
+    ({ memory, userId } = createTestMemory({customPrompt:"L'utilisateur travail pour une régie immobilière!"}));
     // Reset all memories before each test
     await memory.reset(userId);
   });
@@ -56,48 +26,12 @@ describe("Memory Class facts regression tests", () => {
 
   describe("Edge cases for Facts", () => {
 
-    it("should not extract personal information as facts from business queries", async () => {
-      //  type?: "factual" | "episodic" | "semantic"|"procedural" | "assistant_preference";
-      // Capture a query that contains a name but is asking for contact information
-      const result = (await memory.capture(
-        "je cherche le téléphone de mon client Alphonse MAGLOIRE",
-        userId,
-        {},
-      )) as SearchResult;
-
-      // Verify no memory was created (business query)
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      expect(result.results.length).toBe(1);
-      const type = result.results[0]?.type; 
-      expect(["procedural","episodic"].includes(type)).toBe(true);
-      // Now search for memories that might contain "Alphonse MAGLOIRE"
-      // const searchResult = (await memory.retrieve(
-      //   "Qui est Alphonse MAGLOIRE?",
-      //   userId,
-      //   {},
-      // )) as SearchResult;
-
-      // // Verify no personal fact like "Je m'appelle Alphonse MAGLOIRE" was created
-      // expect(searchResult).toBeDefined();
-      // expect(searchResult.results).toBeDefined();
-      // expect(Array.isArray(searchResult.results)).toBe(true);
-      // expect(searchResult.results.length).toBe(0);
-      
-      // // Ensure no memory contains the name as a personal fact
-      // const allMemories = await memory.getAll(userId, {});
-      // const personalFacts = allMemories.results.filter(mem => 
-      //   mem.memory.toLowerCase().includes("Alphonse MAGLOIRE")
-      // );
-      // expect(personalFacts.length).toBe(0);
-    });
 
-    it("should add a single procedural memory", async () => {
+    it("should not add memory: Qui suis-je ?", async () => {
       const customFacts = "Je suis Olivier Poulain\nIT et je travaille chez Immeuble SA";
       const result = (await memory.capture([
         {role:"user", content:"Qui suis-je ?"},
-        {role:"assistant", content:"Vous êtes Olivier Poulain, Chef de Projets au département IT & Gestion de projet, dans l'équipe IT de Immeuble SA. Ces informations proviennent de votre profil collaborateur enregistré dans le système interne de Immeuble SA"}],
+        {role:"assistant", content:"Vous êtes Olivier Poulain, Chef de Projets au département IT & Gestion de projet, dans l'équipe IT de Immeuble SA"}],
         userId,
         {customFacts},
       )) as SearchResult;
@@ -106,18 +40,20 @@ describe("Memory Class facts regression tests", () => {
       expect(result.results.length).toBe(0);
       // expect(result.results[0]?.type).toBe("factual");
     });
-    it("episodic memory: Je veux manger des sushis pour ma pause de midi.", async () => {
+    it("episodic: Je veux manger des sushis pour ma pause de midi.", async () => {
       const customFacts = "Je suis Olivier Poulain\nIT et je travaille chez Immeuble SA";
       const result = (await memory.capture([
-        {role:"user", content:"Je veux manger des sushis pour ma pause de midi."}],
+        {role:"user", content:"J'ai faim, je veux manger des sushis pour ma pause de midi."},
+        {role:"user", content:"Cherche un restaurant de sushis près de chez moi."}],
         userId,
         {customFacts},
       )) as SearchResult;
 
       expect(result).toBeDefined();
       expect(result.results).toBeDefined();
-      expect(result.results.length).toBeGreaterThan(0);
+      expect(result.results.length).toBeGreaterThan(1);
       expect(result.results[0]?.type).toBe("episodic");
+      expect(result.results[1]?.type).toBe("episodic");
     });
 
 
@@ -136,6 +72,24 @@ describe("Memory Class facts regression tests", () => {
       expect(result.results[0]?.type).toBe("assistant_preference");
     });
 
+    it("business:je cherche le téléphone de mon client Alphonse MAGLOIRE", async () => {
+      //  type?: "factual" | "episodic" | "semantic"|"procedural" | "assistant_preference";
+      // Capture a query that contains a name but is asking for contact information
+      const result = (await memory.capture(
+        "je cherche le téléphone de mon client Alphonse MAGLOIRE",
+        userId,
+        {},
+      )) as SearchResult;
+
+      // Verify no memory was created (business query)
+      expect(result).toBeDefined();
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.results)).toBe(true);
+      expect(result.results.length).toBe(1);
+      const type = result.results[0]?.type; 
+      expect(["procedural","episodic"].includes(type)).toBe(true);
+    });
+
     it("business:Le logement de Alphonse MAGLOIRE  au 5ème étage est de combien pièces", async () => {
       const result = (await memory.capture([
         {role:"user", content:"Le logement de Alphonse MAGLOIRE  au 5ème étage est de combien pièces.",},

package/tests/memory.test.ts

@@ -2,6 +2,7 @@
 import { MemoriesLite } from "../src";
 import { MemoryItem, SearchResult } from "../src/types";
 import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
 
 dotenv.config();
 
@@ -9,41 +10,11 @@ jest.setTimeout(30000); // Increase timeout to 30 seconds
 
 describe("Memory Class", () => {
   let memory: MemoriesLite;
-  const userId =
-    Math.random().toString(36).substring(2, 15) +
-    Math.random().toString(36).substring(2, 15);
-
-  const dimension = 768;
+  let userId: string;
 
   beforeEach(async () => {
-    // Initialize with default configuration
-    memory = new MemoriesLite({
-      version: "v1.1",
-      disableHistory: true,
-      embedder: {
-        provider: "openai",
-        config: {
-          dimension,
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "text-embedding-3-small",
-        },
-      },
-      vectorStore: {
-        provider: "lite",
-        config: {
-          dimension,
-          rootPath: ":memory:",
-        },
-      },
-      llm: {
-        provider: "openai",
-        config: {
-          apiKey: process.env.OPENAI_API_KEY || "",
-          model: "gpt-4.1-mini",
-        },
-      },
-      historyDbPath: ":memory:", // Use in-memory SQLite for tests
-    });
+    // Initialize memory via helper
+    ({ memory, userId } = createTestMemory({}));
     // Reset all memories before each test
     await memory.reset(userId);
   });
@@ -101,7 +72,7 @@ describe("Memory Class", () => {
       expect(typeof result.memory).toBe("string");
     });
 
-    it("should update a memory", async () => {
+    it("should directly update a memory content", async () => {
       // First add a memory
       const addResult = (await memory.capture(
         "I love speaking foreign languages especially Spanish",
@@ -127,23 +98,19 @@ describe("Memory Class", () => {
     it("should update a memory", async () => {
       // First add a memory
       const init = await memory.capture("I love to drink red wine", userId, {});
-      // expect(init.results?.[0]?.id).toBeDefined();
-      const initId = init.results?.[0]?.id;
+      expect(init.results?.[0]?.id).toBeDefined();
       const addResult = (await memory.capture("I love to drink red wine with friends", userId, {})) as SearchResult;
       expect(addResult.results?.[0]?.id).toBeDefined();
 
-      const memoryId = addResult.results[0].id;
-      expect(memoryId).toBe(initId);
-      // Delete the memory
-      await memory.delete(memoryId, userId);
+      const updated = (await memory.get(addResult.results[0].id, userId))!;
 
-      // Try to get the deleted memory - should throw or return null
-      const result = await memory.get(memoryId, userId);
-      expect(result).toBeNull();
+      expect(updated).toBeDefined();
+      expect(updated.id).toBe(init.results[0].id);
+      expect(updated.type).toBe(init.results[0].type);
     });
 
 
-    it("should get all memories for distinct users", async () => {
+    it.only("should get all memories for distinct users", async () => {
       // Add a few memories
       await memory.capture("I love visiting new places in the winters", userId, {});
       await memory.capture("I like to rule the world", userId, {});
@@ -350,42 +317,17 @@ describe("Memory Class", () => {
 
   describe("Memory with Custom Configuration", () => {
     let customMemory: MemoriesLite;
-
-    beforeEach(() => {
-      customMemory = new MemoriesLite({
-        version: "v1.1",
-        disableHistory: true,
-        embedder: {
-          provider: "openai",
-          config: {
-            dimension,
-            apiKey: process.env.OPENAI_API_KEY || "",
-            model: "text-embedding-3-small",
-          },
-        },
-        vectorStore: {
-          provider: "lite",
-          config: {
-            dimension,
-            rootPath: ":memory:",
-          },
-        },
-        llm: {
-          provider: "openai",
-          config: {
-            apiKey: process.env.OPENAI_API_KEY || "",
-            model: "gpt-4.1-mini",
-          },
-        },
-        historyDbPath: ":memory:", // Use in-memory SQLite for tests
-      });
+    beforeEach(async () => {
+      // Initialize customMemory via helper
+      ({ memory: customMemory, userId } = createTestMemory({}));
+      // Reset before custom tests
+      await customMemory.reset(userId);
     });
 
     afterEach(async () => {
       await customMemory.reset(userId);
     });
 
-
     it("should perform semantic search with custom embeddings", async () => {
       // Add test memories
       await customMemory.capture("The weather in London is rainy today", userId, {});

package/tests/memory.update.test.ts

@@ -0,0 +1,150 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import { MemoryItem, SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(30000); // Increase timeout to 30 seconds
+
+describe("Memory Updates - Type Preservation", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  beforeEach(async () => {
+    // Initialize memory via helper
+    ({ memory, userId } = createTestMemory({}));
+    // Reset all memories before each test
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    // Clean up after each test
+    await memory.reset(userId);
+  });
+
+  describe("Memory Type Preservation During Updates", () => {
+    it("should preserve memory type when updating content", async () => {
+      // Add a factual memory
+      const factResult = (await memory.capture(
+        "I am allergic to peanuts",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(factResult.results.length).toBeGreaterThan(0);
+      expect(factResult.results[0]?.type).toBe("factual");
+      
+      const factId = factResult.results[0].id;
+      
+      // Update the factual memory
+      await memory.update(factId, "I am severely allergic to peanuts and tree nuts", userId);
+      
+      // Verify type preservation
+      const updatedFact = await memory.get(factId, userId);
+      expect(updatedFact).not.toBeNull();
+      expect(updatedFact?.type).toBe("factual");
+      expect(updatedFact?.memory).toBe("I am severely allergic to peanuts and tree nuts");
+    });
+
+    it("should preserve assistant_preference type when updating", async () => {
+      // Add a preference memory
+      const prefResult = (await memory.capture(
+        "please respond to me in French",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(prefResult.results.length).toBeGreaterThan(0);
+      expect(prefResult.results[0]?.type).toBe("assistant_preference");
+      
+      const prefId = prefResult.results[0].id;
+      
+      // Update the preference memory
+      await memory.update(prefId, "please respond to me in Spanish", userId);
+      
+      // Verify type preservation
+      const updatedPref = await memory.get(prefId, userId);
+      expect(updatedPref).not.toBeNull();
+      expect(updatedPref?.type).toBe("assistant_preference");
+      expect(updatedPref?.memory).toBe("please respond to me in Spanish");
+    });
+
+    it("should preserve episodic memory type when updating", async () => {
+      // Add an episodic memory
+      const episodicResult = (await memory.capture(
+        "I have a doctor's appointment tomorrow at 2pm",
+        userId,
+        {},
+      )) as SearchResult;
+      
+      expect(episodicResult.results.length).toBeGreaterThan(0);
+      expect(episodicResult.results[0]?.type).toBe("episodic");
+      
+      const episodicId = episodicResult.results[0].id;
+      
+      // Update the episodic memory
+      await memory.update(episodicId, "My doctor's appointment was rescheduled to Friday at 3pm", userId);
+      
+      // Verify type preservation
+      const updatedEpisodic = await memory.get(episodicId, userId);
+      expect(updatedEpisodic).not.toBeNull();
+      expect(updatedEpisodic?.type).toBe("episodic");
+      expect(updatedEpisodic?.memory).toBe("My doctor's appointment was rescheduled to Friday at 3pm");
+    });
+    
+    it.skip("should preserve memory metadata when updating content", async () => {
+      // Mock the vector store to verify metadata is preserved
+      const mockVectorStore = {
+        insert: jest.fn().mockResolvedValue(undefined),
+        search: jest.fn().mockResolvedValue([{
+          id: 'test-id',
+          score: 0.9,
+          metadata: { 
+            type: 'factual',
+            userId,
+            timestamp: Date.now(),
+            custom: 'test-value'
+          },
+          values: []
+        }]),
+        get: jest.fn().mockResolvedValue({
+          id: 'test-id',
+          metadata: { 
+            type: 'factual',
+            userId,
+            timestamp: Date.now(),
+            custom: 'test-value'
+          },
+          values: []
+        }),
+        update: jest.fn().mockResolvedValue(undefined),
+        list: jest.fn(),
+        delete: jest.fn(),
+        deleteCol: jest.fn(),
+        ensureCollection: jest.fn(),
+      };
+      
+      // Mock the getVectorStore method to return our mock
+      jest.spyOn(memory, 'getVectorStore').mockResolvedValue(mockVectorStore as any);
+      
+      // Perform an update
+      await memory.update('test-id', 'Updated content', userId);
+      
+      // Verify mockVectorStore.update was called with metadata preserved
+      expect(mockVectorStore.update).toHaveBeenCalled();
+      const updateArgs = mockVectorStore.update.mock.calls[0];
+      
+      // Verify the ID and content are correct
+      expect(updateArgs[0]).toBe('test-id'); // ID
+      
+      // Verify that metadata is passed and preserved in the update call
+      const metadataArg = updateArgs[2];
+      expect(metadataArg).toBeDefined();
+      expect(metadataArg.type).toBe('factual');
+      expect(metadataArg.userId).toBe(userId);
+      expect(metadataArg.custom).toBe('test-value');
+    });
+  });
+});