memories-lite 0.99.2 → 0.99.3

package/dist/memory/index.d.ts

@@ -33,7 +33,7 @@ export declare class MemoriesLite {
     capture(messages: string | Message[], userId: string, config: AddMemoryOptions): Promise<SearchResult>;
     get(memoryId: string, userId: string): Promise<MemoryItem | null>;
     retrieve(query: string, userId: string, config: SearchMemoryOptions): Promise<SearchResult>;
-    update(memoryId: string, data: string, userId: string): Promise<{
+    update(memoryId: string, data: string, userId: string, metadata?: Record<string, any>): Promise<{
         message: string;
     }>;
     delete(memoryId: string, userId: string): Promise<{

package/dist/memory/index.js

@@ -271,10 +271,10 @@ class MemoriesLite {
             results,
         };
     }
-    async update(memoryId, data, userId) {
+    async update(memoryId, data, userId, metadata = {}) {
         // await this._captureEvent("update", { memory_id: memoryId });
         const embedding = await this.embedder.embed(data);
-        await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+        await this.updateMemory(memoryId, data, { [data]: embedding }, metadata, userId);
         return { message: "Memory updated successfully!" };
     }
     async delete(memoryId, userId) {
@@ -388,20 +388,21 @@ class MemoriesLite {
             throw new Error(`Memory with ID ${memoryId} not found`);
         }
         const prevValue = existingMemory.payload.data;
+        const originalPayload = (existingMemory.payload ?? {});
         const embedding = existingEmbeddings[data] || (await this.embedder.embed(data));
+        //
+        // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
+        // - title: keep original unless explicitly changed
+        // - discussionId, userId, agentId/runId: always keep original
+        const title = (typeof metadata.title === "string" && metadata.title.trim())
+            ? metadata.title.trim()
+            : originalPayload.title;
         const newMetadata = {
-            ...metadata,
+            ...originalPayload,
             data,
             hash: (0, crypto_1.createHash)("md5").update(data).digest("hex"),
-            type: existingMemory.payload.type,
-            createdAt: existingMemory.payload.createdAt,
             updatedAt: new Date().toISOString(),
-            ...(existingMemory.payload.agentId && {
-                agentId: existingMemory.payload.agentId,
-            }),
-            ...(existingMemory.payload.runId && {
-                runId: existingMemory.payload.runId,
-            }),
+            title: title,
         };
         await vectorStore.update(memoryId, embedding, newMetadata);
         await this.db.addHistory(memoryId, prevValue, data, "UPDATE", newMetadata.createdAt, newMetadata.updatedAt);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "memories-lite",
-  "version": "0.99.2",
+  "version": "0.99.3",
   "description": "A lightweight memory system for LLM agents",
   "author": "olivier@evaletolab.ch",
   "main": "dist/index.js",

package/src/memory/index.ts

@@ -228,7 +228,7 @@ export class MemoriesLite {
     console.log(`-- 🧠 Memory created: "${title}" (${memoryType})`);
 
     return [{
-      id: memoryId,
+              id: memoryId,
       memory: summary,
       type: memoryType,
       metadata: { title, event: "ADD" },
@@ -292,7 +292,7 @@ export class MemoriesLite {
       userId,
       filters,
       capturePrompt,
-    );
+        );
 
     return {
       results: vectorStoreResult,
@@ -403,10 +403,15 @@ export class MemoriesLite {
     };
   }
 
-  async update(memoryId: string, data: string, userId: string): Promise<{ message: string }> {
+  async update(
+    memoryId: string,
+    data: string,
+    userId: string,
+    metadata: Record<string, any> = {},
+  ): Promise<{ message: string }> {
     // await this._captureEvent("update", { memory_id: memoryId });
     const embedding = await this.embedder.embed(data);
-    await this.updateMemory(memoryId, data, { [data]: embedding }, {}, userId);
+    await this.updateMemory(memoryId, data, { [data]: embedding }, metadata, userId);
     return { message: "Memory updated successfully!" };
   }
 
@@ -564,22 +569,24 @@ export class MemoriesLite {
     }
 
     const prevValue = existingMemory.payload.data;
+    const originalPayload: Record<string, any> = (existingMemory.payload ?? {}) as Record<string, any>;
     const embedding =
       existingEmbeddings[data] || (await this.embedder.embed(data));
 
-    const newMetadata = {
-      ...metadata,
+    //
+    // Preserve origin fields to avoid corrupting ownership/linkage (discussionId/userId/agentId).
+    // - title: keep original unless explicitly changed
+    // - discussionId, userId, agentId/runId: always keep original
+    const title =
+      (typeof metadata.title === "string" && metadata.title.trim())
+        ? metadata.title.trim()
+        : originalPayload.title;
+    const newMetadata: Record<string, any> = {
+      ...originalPayload,
       data,
       hash: createHash("md5").update(data).digest("hex"),
-      type: existingMemory.payload.type,
-      createdAt: existingMemory.payload.createdAt,
       updatedAt: new Date().toISOString(),
-      ...(existingMemory.payload.agentId && {
-        agentId: existingMemory.payload.agentId,
-      }),
-      ...(existingMemory.payload.runId && {
-        runId: existingMemory.payload.runId,
-      }),
+      title: title,
     };
 
     await vectorStore.update(memoryId, embedding, newMetadata);

package/tests/lite.spec.ts

@@ -132,35 +132,35 @@ describe('LiteVectorStore Private Methods', () => {
       //
       // discussion with Infinity halfLife → old memories have same score as new
       const payload: MemoryPayload = { memoryId: 'mem-d2', userId: userId, type: 'discussion', createdAt: veryOldDate };
-      const cosineScore = 0.9;
+        const cosineScore = 0.9;
       const expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBe(1); // Score constant = 1
     });
 
     it('should handle assistant_preference with no decay (Infinity half-life)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
-      const cosineScore = 0.7;
-      const expectedRecency = 1.0;
-      const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeCloseTo(expectedScore, 5);
+        const payload: MemoryPayload = { memoryId: 'mem-a1', userId: userId, type: 'assistant_preference', createdAt: veryOldDate };
+        const cosineScore = 0.7;
+        const expectedRecency = 1.0;
+        const expectedScore = scoring.assistant_preference.alpha * cosineScore + scoring.assistant_preference.beta * expectedRecency + scoring.assistant_preference.gamma;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should use default scoring if type is missing', () => {
       const payload: MemoryPayload = { memoryId: 'mem-def1', userId: userId, createdAt: sevenDaysAgo }; // No type specified
-      const cosineScore = 0.8;
-      const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
-      const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeCloseTo(expectedScore, 5);
+        const cosineScore = 0.8;
+        const expectedRecency = (store as any).calculateRecencyScore(sevenDaysAgo, scoring.default.halfLifeDays);
+        const expectedScore = scoring.default.alpha * cosineScore + scoring.default.beta * expectedRecency + scoring.default.gamma;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeCloseTo(expectedScore, 5);
     });
 
     it('should return score >= 0 even with negative cosine similarity', () => {
       const payload: MemoryPayload = { memoryId: 'mem-neg1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
-      const cosineScore = -0.5;
-      const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-      expect(hybridScore).toBeGreaterThanOrEqual(0);
+        const cosineScore = -0.5;
+        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
+        expect(hybridScore).toBeGreaterThanOrEqual(0);
     });
 
   });