memories-lite 0.9.5 → 0.99.1

package/src/types/index.ts

@@ -72,11 +72,8 @@ export interface MemoryTypeConfig {
 }
 
 export interface MemoryScoringConfig {
-  todo: MemoryTypeConfig;
-  procedural: MemoryTypeConfig;
-  episodic: MemoryTypeConfig;
-  factual: MemoryTypeConfig;
   assistant_preference: MemoryTypeConfig;
+  discussion: MemoryTypeConfig;
   default: MemoryTypeConfig; // Fallback if type is missing or unknown
 }
 
@@ -103,7 +100,7 @@ export interface MemoryConfig {
   enableGraph?: boolean;
 }
 
-export type MemoryType = 'procedural' | 'todo' | 'episodic' | 'factual' | 'assistant_preference';
+export type MemoryType = 'assistant_preference' | 'discussion';
 
 export interface MemoryItem {
   id: string;
@@ -164,31 +161,13 @@ export const MemoryConfigSchema = z.object({
         dimension: z.number().optional(),
         client: z.any().optional(),
         scoring: z.object({
-          todo: z.object({
-            alpha: z.number(),
-            beta: z.number(),
-            gamma: z.number(),
-            halfLifeDays: z.number(),
-          }),
-          procedural: z.object({
-            alpha: z.number(),
-            beta: z.number(),
-            gamma: z.number(),
-            halfLifeDays: z.number(),
-          }),
-          episodic: z.object({
-            alpha: z.number(),
-            beta: z.number(),
-            gamma: z.number(),
-            halfLifeDays: z.number(),
-          }),
-          factual: z.object({
+          assistant_preference: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),
             halfLifeDays: z.number(),
           }),
-          assistant_preference: z.object({
+          discussion: z.object({
             alpha: z.number(),
             beta: z.number(),
             gamma: z.number(),

package/tests/lite.spec.ts

@@ -25,6 +25,10 @@ jest.mock('sqlite3', () => {
 });
 
 
+/**
+ * Tests for LiteVectorStore private methods
+ * Updated to use new memory types: assistant_preference and discussion
+ */
 describe('LiteVectorStore Private Methods', () => {
   let store: LiteVectorStore;
   const userId = 'test-user';
@@ -98,59 +102,65 @@ describe('LiteVectorStore Private Methods', () => {
     const veryOldDate = new Date(now.getTime() - 400 * 24 * 60 * 60 * 1000).toISOString();
     const scoring = DEFAULT_MEMORY_CONFIG.vectorStore.config.scoring!;
 
-    it('should prioritize cosine similarity for factual memory (high alpha)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-f1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
+    it('should prioritize cosine similarity for assistant_preference (high alpha)', () => {
+      //
+      // assistant_preference: { alpha: 0.60, beta: 0.05, gamma: 0.35, halfLifeDays: Infinity }
+      const payload: MemoryPayload = { memoryId: 'mem-ap1', userId: userId, type: 'assistant_preference', createdAt: twoDaysAgo };
       const cosineScore = 0.9;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.factual.halfLifeDays);
-      const expectedScore = scoring.factual.alpha * cosineScore + scoring.factual.beta * expectedRecency + scoring.factual.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      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);
-      expect(scoring.factual.alpha * cosineScore).toBeGreaterThan(scoring.factual.beta * expectedRecency);
+      // alpha * cosine (0.54) > beta * recency (0.05)
+      expect(scoring.assistant_preference.alpha * cosineScore).toBeGreaterThan(scoring.assistant_preference.beta * expectedRecency);
     });
 
-    it('should prioritize recency for episodic memory (high beta, short half-life)', () => {
-      const payload: MemoryPayload = { memoryId: 'mem-e1', userId: userId, type: 'episodic', createdAt: twoDaysAgo };
+    it('should return constant score for discussion (beta=1, alpha=0, gamma=0)', () => {
+      //
+      // discussion: { alpha: 0, beta: 1, gamma: 0, halfLifeDays: Infinity }
+      // Score = 0 * cosine + 1 * recency + 0 = 1 (constant)
+      const payload: MemoryPayload = { memoryId: 'mem-d1', userId: userId, type: 'discussion', createdAt: twoDaysAgo };
       const cosineScore = 0.5;
-      const expectedRecency = (store as any).calculateRecencyScore(twoDaysAgo, scoring.episodic.halfLifeDays);
-      const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
+      const expectedRecency = 1.0; // Infinity halfLife → recency = 1
+      const expectedScore = scoring.discussion.alpha * cosineScore + scoring.discussion.beta * expectedRecency + scoring.discussion.gamma;
       const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
       expect(hybridScore).toBeCloseTo(expectedScore, 5);
-      expect(scoring.episodic.beta * expectedRecency).toBeGreaterThan(0.2);
+      expect(hybridScore).toBe(1); // Score constant = 1
     });
 
-    it('should have low score for old episodic memory', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-e2', userId: userId, type: 'episodic', createdAt: veryOldDate };
-        const cosineScore = 0.9;
-        const expectedRecency = (store as any).calculateRecencyScore(veryOldDate, scoring.episodic.halfLifeDays);
-        const expectedScore = scoring.episodic.alpha * cosineScore + scoring.episodic.beta * expectedRecency + scoring.episodic.gamma;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(expectedRecency).toBeLessThan(0.01);
-        expect(hybridScore).toBeCloseTo(scoring.episodic.alpha * cosineScore + scoring.episodic.gamma, 5);
+    it('should have constant score for old discussion memory (no decay)', () => {
+      //
+      // 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 expectedRecency = 1.0; // Infinity halfLife → recency = 1 even for old dates
+      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-d1', 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 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);
     });
 
     it('should return score >= 0 even with negative cosine similarity', () => {
-        const payload: MemoryPayload = { memoryId: 'mem-s1', userId: userId, type: 'factual', createdAt: twoDaysAgo };
-        const cosineScore = -0.5;
-        const hybridScore = (store as any).calculateHybridScore(cosineScore, payload);
-        expect(hybridScore).toBeGreaterThanOrEqual(0);
+      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);
     });
 
   });

package/tests/memory.discussion.test.ts

@@ -0,0 +1,279 @@
+/// <reference types="jest" />
+import { MemoriesLite } from "../src";
+import { SearchResult } from "../src/types";
+import dotenv from "dotenv";
+import { createTestMemory } from "./init.mem";
+
+dotenv.config();
+
+jest.setTimeout(60000); // 60s pour les tests avec LLM
+
+/**
+ * Tests pour le nouveau type de mémoire 'discussion'
+ * Permet de mémoriser une discussion avec synthèse (title + summary)
+ */
+describe("Memory Discussion - Synthèse de discussions", () => {
+  let memory: MemoriesLite;
+  let userId: string;
+
+  //
+  // Exemple de discussion à synthétiser
+  const discussionMessages = [
+    {
+      role: "user",
+      content: "Tu dois vérifier les autorisations (ou APA) de la FAO de Genève, et ensuite tu dois extraire toutes les adresses et chercher nos immeubles. Merci de me mettre les liens des FAO que tu jugeras utiles."
+    },
+    {
+      role: "assistant", 
+      content: `Voici un premier lot traité. Dites-moi si vous voulez que je continue sur plus d'avis.
+
+Adresses extraites et recherche de nos immeubles
+- Chemin Émile-Bressler 19, 1226 Thônex
+  - Immeubles PRSA à proximité (200 m) : aucun trouvé.
+  - FAO: Requête M/341685/1 — Démolition d'une villa
+- Chemin du Port 9, 1246 Corsier
+  - À vérifier (souhaitez-vous que je cherche nos immeubles autour de cette adresse ?)
+  - FAO: Requête M/341714/1 — Démolition
+- Boulevard de Saint‑Georges 46, 1205 Genève (Plainpalais)
+  - À vérifier (je peux lancer la recherche de nos immeubles).
+  - FAO: Autorisation DD 330818 — Transformation`
+    },
+    {
+      role: "user",
+      content: "oui merci pour le premier"
+    },
+    {
+      role: "assistant",
+      content: `Parfait. Je poursuis avec ces trois adresses et vous reviens avec:
+- adresses exactes confirmées
+- présence/absence de nos immeubles à 200 m
+- liens FAO utiles
+
+Cibles:
+- Chemin du Port 9, 1246 Corsier
+- Boulevard de Saint‑Georges 46, 1205 Genève
+- Chemin du Champ‑des‑Bois 8, 1255 Veyrier`
+    },
+    {
+      role: "user",
+      content: "oui"
+    },
+    {
+      role: "assistant",
+      content: `Voici la suite.
+
+Résultats par adresse (rayon 200 m)
+- Chemin du Port 9, 1246 Corsier — aucun immeuble PRSA trouvé.
+- Boulevard de Saint‑Georges 46, 1205 Genève — aucun immeuble PRSA trouvé.
+- Chemin du Champ‑des‑Bois 8, 1255 Veyrier — aucun immeuble PRSA trouvé.
+
+Souhaitez-vous que je:
+- élargisse à 300–500 m,
+- continue l'extraction sur d'autres avis FAO récents (démolitions/transformations/APA), 
+- ou cible des communes/quartiers spécifiques ?`
+    }
+  ];
+
+  beforeEach(async () => {
+    ({ memory, userId } = createTestMemory({}));
+    await memory.reset(userId);
+  });
+
+  afterEach(async () => {
+    await memory.reset(userId);
+  });
+
+  describe("Capture de discussion", () => {
+    
+    it("should capture a discussion and generate exactly ONE memory with title + summary", async () => {
+      //
+      // Capturer la discussion avec type 'discussion'
+      const result = await memory.capture(discussionMessages, userId, {
+        metadata: { 
+          type: 'discussion',
+          discussionId: '7c3e43ac-7621-470d-a22e-82713c3a113e'
+        }
+      }) as SearchResult;
+
+      expect(result).toBeDefined();
+      expect(result.results).toBeDefined();
+      expect(Array.isArray(result.results)).toBe(true);
+      
+      //
+      // ✅ Vérifier qu'UNE SEULE mémoire est créée par capture
+      expect(result.results.length).toBe(1);
+
+      //
+      // Vérifier que la mémoire contient title et type
+      const mem = result.results[0];
+      expect(mem.id).toBeDefined();
+      expect(mem.type).toBe('discussion');
+      expect(mem.memory).toBeDefined(); // summary
+      expect(mem.metadata?.title).toBeDefined();
+      
+      console.log('--- Title:', mem.metadata?.title);
+      console.log('--- Summary:', mem.memory);
+      
+      //
+      // ✅ Vérifier qu'il n'y a bien qu'une seule mémoire stockée
+      const allMemories = await memory.getAll(userId, { type: 'discussion' });
+      expect(allMemories.results.length).toBe(1);
+    });
+
+    it("should use custom capturePrompt when provided", async () => {
+      const customPrompt = `Tu es un expert en synthèse. Génère:
+1. TITRE: Un titre technique en français (max 8 mots)
+2. SUMMARY: Résumé technique des actions effectuées (max 50 mots)
+
+Discussion:
+`;
+      
+      const result = await memory.capture(discussionMessages, userId, {
+        capturePrompt: customPrompt,
+        metadata: { 
+          type: 'discussion',
+          discussionId: 'custom-test-id'
+        }
+      }) as SearchResult;
+
+      expect(result).toBeDefined();
+      expect(result.results.length).toBeGreaterThan(0);
+      expect(result.results[0].type).toBe('discussion');
+    });
+
+    it("should retrieve discussion memories by semantic search with title in metadata", async () => {
+      //
+      // D'abord capturer la discussion
+      const captureResult = await memory.capture(discussionMessages, userId, {
+        metadata: { 
+          type: 'discussion',
+          discussionId: 'search-test-id'
+        }
+      }) as SearchResult;
+      
+      const originalTitle = captureResult.results[0].metadata?.title;
+      expect(originalTitle).toBeDefined();
+
+      //
+      // Recherche sémantique avec retrieve()
+      const searchResult = await memory.retrieve(
+        "recherche FAO autorisation immeuble Genève",
+        userId,
+        { filters: { type: 'discussion' } }
+      ) as SearchResult;
+
+      expect(searchResult).toBeDefined();
+      expect(searchResult.results).toBeDefined();
+      expect(searchResult.results.length).toBeGreaterThan(0);
+      
+      //
+      // ✅ Vérifier que le title est dans metadata
+      expect(searchResult.results[0].metadata?.title).toBeDefined();
+      expect(searchResult.results[0].metadata?.title).toBe(originalTitle);
+      expect(searchResult.results[0].score).toBeDefined();
+      expect(searchResult.results[0].type).toBe('discussion');
+      
+      console.log('--- retrieve() title:', searchResult.results[0].metadata?.title);
+    });
+
+    it("should list all discussion memories with title in metadata (getAll)", async () => {
+      //
+      // Capturer plusieurs discussions
+      const capture1 = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'disc-1' }
+      }) as SearchResult;
+      
+      const capture2 = await memory.capture([
+        { role: "user", content: "Comment résilier un bail ?" },
+        { role: "assistant", content: "Voici la procédure de résiliation..." }
+      ], userId, {
+        metadata: { type: 'discussion', discussionId: 'disc-2' }
+      }) as SearchResult;
+
+      //
+      // Lister toutes les mémoires discussion avec getAll()
+      const allResult = await memory.getAll(userId, { type: 'discussion' }) as SearchResult;
+
+      expect(allResult).toBeDefined();
+      expect(allResult.results.length).toBe(2);
+      expect(allResult.results.every(r => r.type === 'discussion')).toBe(true);
+      
+      //
+      // ✅ Vérifier que chaque mémoire a un title dans metadata
+      expect(allResult.results.every(r => r.metadata?.title !== undefined)).toBe(true);
+      
+      console.log('--- getAll() titles:', allResult.results.map(r => r.metadata?.title));
+    });
+
+    it("should get a single discussion memory with title in metadata (get)", async () => {
+      //
+      // Capturer
+      const captureResult = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'get-test' }
+      }) as SearchResult;
+
+      const memoryId = captureResult.results[0].id;
+      const originalTitle = captureResult.results[0].metadata?.title;
+
+      //
+      // Récupérer avec get()
+      const getResult = await memory.get(memoryId, userId);
+
+      expect(getResult).not.toBeNull();
+      expect(getResult?.type).toBe('discussion');
+      expect(getResult?.memory).toBeDefined();
+      
+      //
+      // ✅ Vérifier que le title est dans metadata
+      expect(getResult?.metadata?.title).toBeDefined();
+      expect(getResult?.metadata?.title).toBe(originalTitle);
+      
+      console.log('--- get() title:', getResult?.metadata?.title);
+    });
+
+    it("should delete a discussion memory", async () => {
+      //
+      // Capturer
+      const result = await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'delete-test' }
+      }) as SearchResult;
+
+      const memoryId = result.results[0].id;
+
+      //
+      // Supprimer
+      await memory.delete(memoryId, userId);
+
+      //
+      // Vérifier suppression
+      const deleted = await memory.get(memoryId, userId);
+      expect(deleted).toBeNull();
+    });
+  });
+
+  describe("Scoring discussion", () => {
+    
+    it("should have constant score (beta=1, halfLife=Infinity)", async () => {
+      //
+      // Capturer une discussion
+      await memory.capture(discussionMessages, userId, {
+        metadata: { type: 'discussion', discussionId: 'score-test' }
+      });
+
+      //
+      // Rechercher immédiatement
+      const result1 = await memory.retrieve("FAO Genève", userId, {
+        filters: { type: 'discussion' }
+      }) as SearchResult;
+
+      //
+      // Le score ne devrait pas dépendre du temps (halfLife=Infinity)
+      // Avec alpha=0, beta=1, gamma=0, le score = recency = 1 (constant)
+      expect(result1.results.length).toBeGreaterThan(0);
+      expect(result1.results[0].score).toBeDefined();
+      
+      console.log('--- Score:', result1.results[0].score);
+    });
+  });
+});
+

package/tests/memory.update.test.ts

@@ -8,7 +8,11 @@ dotenv.config();
 
 jest.setTimeout(30000); // Increase timeout to 30 seconds
 
-describe("Memory Updates - Type Preservation", () => {
+/**
+ * @deprecated Tests use factual/episodic types that have been removed
+ * These tests are skipped - see migration to discussion memory type
+ */
+describe.skip("Memory Updates - Type Preservation (DEPRECATED)", () => {
   let memory: MemoriesLite;
   let userId: string;
 

package/tests/memory.facts.test.ts

@@ -1,168 +0,0 @@
-/// <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 Class facts regression tests", () => {
-  let memory: MemoriesLite;
-  let userId: string;
-
-  beforeEach(async () => {
-    // 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);
-  });
-
-  afterEach(async () => {
-    // Clean up after each test
-    await memory.reset(userId);
-  });
-
-  describe("Edge cases for Facts", () => {
-
-
-    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"}],
-        userId,
-        {customFacts},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(result.results.length).toBe(0);
-      // expect(result.results[0]?.type).toBe("factual");
-    });
-    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:"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(1);
-      expect(result.results[0]?.type).toBe("episodic");
-      expect(result.results[1]?.type).toBe("episodic");
-    });
-
-
-    it("should add assistant_preference memory", async () => {
-      const result = (await memory.capture(
-        "tu dois répondre de manière concise et précise",
-        userId,
-        {},
-      )) as SearchResult;
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      expect(result.results.length).toBeGreaterThan(0);
-      expect(result.results[0]?.id).toBeDefined();
-      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" | "todo"|"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.",},
-        {role:"assitant", content:"Alphonse MAGLOIRE a un logement de 4 pièces au 5ème étage",}],
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      //
-      // result can also be empty 
-      if(result.results.length > 0) {
-        expect(result.results.length).toBe(1);
-        expect(result.results[0]?.type).toBe("procedural");
-      }
-    });
-    
-
-    it("business task are not factual (2)", async () => {
-      const result = (await memory.capture([
-        {role:"user", content:"Quelle est la procédure pour résilier un bail chez Pouet & Compagnie SA ?"}],        
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-
-
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      //
-      // result can also be empty 
-      if(result.results.length > 0) {
-        expect(result.results.length).toBe(1);
-        expect(result.results[0]?.type).toBe("procedural");
-      }
-    });
-
-    it("business:Est-ce que Claude RIBUR est à jour avec son loyer ?", async () => {
-      const result = (await memory.capture([
-        {role:"user", content:"Est-ce que Claude RIBUR est à jour avec son loyer ?"}],
-        userId,
-        {customFacts:"Je suis Olivier Poulain, Je m'occupe de la gérance locataire chez Immeuble SA"},
-      )) as SearchResult;
-      expect(result).toBeDefined();
-      expect(result.results).toBeDefined();
-      expect(Array.isArray(result.results)).toBe(true);
-      expect(result.results.length).toBe(1);
-      expect(result.results[0]?.type).toBe("procedural");
-
-
-    });
-
-
-    it("should add and remove a single memory", async () => {
-      const result = (await memory.capture(
-        "je veux que tu répondes en italien",
-        userId,
-        {},
-      )) as SearchResult;
-      expect(result.results?.[0]?.id).toBeDefined();
-      const memoryId = result.results[0]?.id;
-      await memory.capture(
-        "je ne veux plus que tu répondes en italien",
-        userId,
-        {},
-      ) as SearchResult;
-
-      const id = await memory.get(memoryId, userId);
-      expect(id).toBeNull();
-
-    });
-
-
-  });
-});