@elizaos/plugin-memory 1.0.3 → 1.0.5

package/dist/cjs/index.node.cjs

@@ -126,14 +126,17 @@ class MemoryService extends import_core.Service {
     this.sessionMessageCounts = new Map;
     this.lastExtractionCheckpoints = new Map;
     this.memoryConfig = {
-      shortTermSummarizationThreshold: 5,
+      shortTermSummarizationThreshold: 16,
       shortTermRetainRecent: 10,
+      shortTermSummarizationInterval: 10,
       longTermExtractionEnabled: true,
       longTermVectorSearchEnabled: false,
       longTermConfidenceThreshold: 0.7,
+      longTermExtractionThreshold: 20,
       longTermExtractionInterval: 5,
       summaryModelType: "TEXT_LARGE",
-      summaryMaxTokens: 2500
+      summaryMaxTokens: 2500,
+      summaryMaxNewMessages: 20
     };
   }
   static async start(runtime) {
@@ -154,6 +157,14 @@ class MemoryService extends import_core.Service {
     if (retainRecent) {
       this.memoryConfig.shortTermRetainRecent = parseInt(retainRecent, 10);
     }
+    const summarizationInterval = runtime.getSetting("MEMORY_SUMMARIZATION_INTERVAL");
+    if (summarizationInterval) {
+      this.memoryConfig.shortTermSummarizationInterval = parseInt(summarizationInterval, 10);
+    }
+    const maxNewMessages = runtime.getSetting("MEMORY_MAX_NEW_MESSAGES");
+    if (maxNewMessages) {
+      this.memoryConfig.summaryMaxNewMessages = parseInt(maxNewMessages, 10);
+    }
     const longTermEnabled = runtime.getSetting("MEMORY_LONG_TERM_ENABLED");
     if (longTermEnabled === "false") {
       this.memoryConfig.longTermExtractionEnabled = false;
@@ -164,10 +175,21 @@ class MemoryService extends import_core.Service {
     if (confidenceThreshold) {
       this.memoryConfig.longTermConfidenceThreshold = parseFloat(confidenceThreshold);
     }
+    const extractionThreshold = runtime.getSetting("MEMORY_EXTRACTION_THRESHOLD");
+    if (extractionThreshold) {
+      this.memoryConfig.longTermExtractionThreshold = parseInt(extractionThreshold, 10);
+    }
+    const extractionInterval = runtime.getSetting("MEMORY_EXTRACTION_INTERVAL");
+    if (extractionInterval) {
+      this.memoryConfig.longTermExtractionInterval = parseInt(extractionInterval, 10);
+    }
     import_core.logger.info({
       summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
+      summarizationInterval: this.memoryConfig.shortTermSummarizationInterval,
+      maxNewMessages: this.memoryConfig.summaryMaxNewMessages,
       retainRecent: this.memoryConfig.shortTermRetainRecent,
       longTermEnabled: this.memoryConfig.longTermExtractionEnabled,
+      extractionThreshold: this.memoryConfig.longTermExtractionThreshold,
       extractionInterval: this.memoryConfig.longTermExtractionInterval,
       confidenceThreshold: this.memoryConfig.longTermConfidenceThreshold
     }, "MemoryService initialized");
@@ -228,14 +250,26 @@ class MemoryService extends import_core.Service {
     }
   }
   async shouldRunExtraction(entityId, roomId, currentMessageCount) {
+    const threshold = this.memoryConfig.longTermExtractionThreshold;
     const interval = this.memoryConfig.longTermExtractionInterval;
+    if (currentMessageCount < threshold) {
+      import_core.logger.debug({
+        entityId,
+        roomId,
+        currentMessageCount,
+        threshold,
+        shouldRun: false
+      }, "Extraction check: below threshold");
+      return false;
+    }
     const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
     const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
-    const shouldRun = currentMessageCount >= interval && currentCheckpoint > lastCheckpoint;
+    const shouldRun = currentMessageCount >= threshold && currentCheckpoint > lastCheckpoint;
     import_core.logger.debug({
       entityId,
       roomId,
       currentMessageCount,
+      threshold,
       interval,
       lastCheckpoint,
       currentCheckpoint,
@@ -303,7 +337,7 @@ class MemoryService extends import_core.Service {
       accessCount: row.accessCount
     }));
   }
-  async updateLongTermMemory(id, updates) {
+  async updateLongTermMemory(id, entityId, updates) {
     const db = this.getDb();
     const updateData = {
       updatedAt: new Date
@@ -326,13 +360,13 @@ class MemoryService extends import_core.Service {
     if (updates.accessCount !== undefined) {
       updateData.accessCount = updates.accessCount;
     }
-    await db.update(longTermMemories).set(updateData).where(import_drizzle_orm4.eq(longTermMemories.id, id));
-    import_core.logger.info(`Updated long-term memory: ${id}`);
+    await db.update(longTermMemories).set(updateData).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
+    import_core.logger.info(`Updated long-term memory: ${id} for entity ${entityId}`);
   }
-  async deleteLongTermMemory(id) {
+  async deleteLongTermMemory(id, entityId) {
     const db = this.getDb();
-    await db.delete(longTermMemories).where(import_drizzle_orm4.eq(longTermMemories.id, id));
-    import_core.logger.info(`Deleted long-term memory: ${id}`);
+    await db.delete(longTermMemories).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
+    import_core.logger.info(`Deleted long-term memory: ${id} for entity ${entityId}`);
   }
   async getCurrentSessionSummary(roomId) {
     const db = this.getDb();
@@ -387,7 +421,7 @@ class MemoryService extends import_core.Service {
     import_core.logger.info(`Stored session summary for room ${newSummary.roomId}`);
     return newSummary;
   }
-  async updateSessionSummary(id, updates) {
+  async updateSessionSummary(id, roomId, updates) {
     const db = this.getDb();
     const updateData = {
       updatedAt: new Date
@@ -413,8 +447,8 @@ class MemoryService extends import_core.Service {
     if (updates.embedding !== undefined) {
       updateData.embedding = updates.embedding;
     }
-    await db.update(sessionSummaries).set(updateData).where(import_drizzle_orm4.eq(sessionSummaries.id, id));
-    import_core.logger.info(`Updated session summary: ${id}`);
+    await db.update(sessionSummaries).set(updateData).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.id, id), import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId)));
+    import_core.logger.info(`Updated session summary: ${id} for room ${roomId}`);
   }
   async getSessionSummaries(roomId, limit = 5) {
     const db = this.getDb();
@@ -594,14 +628,31 @@ var summarizationEvaluator = {
     }
     const config = memoryService.getConfig();
     const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
-    import_core2.logger.debug({
-      roomId: message.roomId,
-      currentMessageCount,
-      threshold: config.shortTermSummarizationThreshold,
-      shouldSummarize
-    }, "Summarization validation check");
-    return shouldSummarize;
+    const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
+    if (!existingSummary) {
+      const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
+      import_core2.logger.debug({
+        roomId: message.roomId,
+        currentMessageCount,
+        threshold: config.shortTermSummarizationThreshold,
+        shouldSummarize,
+        reason: "initial_summary_check"
+      }, "Summarization validation check");
+      return shouldSummarize;
+    } else {
+      const newMessageCount = currentMessageCount - existingSummary.lastMessageOffset;
+      const shouldUpdate = newMessageCount >= config.shortTermSummarizationInterval;
+      import_core2.logger.debug({
+        roomId: message.roomId,
+        currentMessageCount,
+        lastOffset: existingSummary.lastMessageOffset,
+        newMessageCount,
+        interval: config.shortTermSummarizationInterval,
+        shouldUpdate,
+        reason: "summary_update_check"
+      }, "Summarization validation check");
+      return shouldUpdate;
+    }
   },
   handler: async (runtime, message) => {
     const memoryService = runtime.getService("memory");
@@ -616,15 +667,25 @@ var summarizationEvaluator = {
       const existingSummary = await memoryService.getCurrentSessionSummary(roomId);
       const lastOffset = existingSummary?.lastMessageOffset || 0;
       const totalMessageCount = await runtime.countMemories(roomId, false, "messages");
+      const newMessageCount = totalMessageCount - lastOffset;
+      const maxNewMessages = config.summaryMaxNewMessages || 50;
+      const messagesToFetch = Math.min(newMessageCount, maxNewMessages);
+      if (messagesToFetch === 0) {
+        import_core2.logger.debug("No new messages to summarize");
+        return;
+      }
+      if (newMessageCount > maxNewMessages) {
+        import_core2.logger.warn(`Capping new messages at ${maxNewMessages} (${newMessageCount} available). Oldest messages will be skipped.`);
+      }
       const newMessages = await runtime.getMemories({
         tableName: "messages",
         roomId,
-        count: config.shortTermSummarizationThreshold,
+        count: messagesToFetch,
         unique: false,
         start: lastOffset
       });
       if (newMessages.length === 0) {
-        import_core2.logger.debug("No new messages to summarize");
+        import_core2.logger.debug("No new messages retrieved");
         return;
       }
       const sortedMessages = newMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
@@ -669,7 +730,7 @@ var summarizationEvaluator = {
       const startTime = existingSummary ? existingSummary.startTime : firstMessage?.createdAt && firstMessage.createdAt > 0 ? new Date(firstMessage.createdAt) : new Date;
       const endTime = lastMessage?.createdAt && lastMessage.createdAt > 0 ? new Date(lastMessage.createdAt) : new Date;
       if (existingSummary) {
-        await memoryService.updateSessionSummary(existingSummary.id, {
+        await memoryService.updateSessionSummary(existingSummary.id, roomId, {
           summary: summaryResult.summary,
           messageCount: existingSummary.messageCount + sortedMessages.length,
           lastMessageOffset: newOffset,
@@ -724,7 +785,7 @@ var LongTermMemoryCategory;
 // src/evaluators/long-term-extraction.ts
 var extractionTemplate = `# Task: Extract Long-Term Memory
 
-You are analyzing a conversation to extract facts that should be remembered long-term about the user.
+You are analyzing a conversation to extract ONLY the most important, persistent facts about the user that should be remembered long-term.
 
 # Recent Messages
 {{recentMessages}}
@@ -743,12 +804,41 @@ You are analyzing a conversation to extract facts that should be remembered long
 8. **definitions**: Custom terms, acronyms, glossaries
 9. **behavioral_patterns**: How the user tends to interact
 
+# STRICT EXTRACTION CRITERIA
+
+**DO EXTRACT** - Facts that are:
+- Explicitly stated personal information (name, role, profession)
+- Repeated patterns across multiple conversations (3+ occurrences)
+- Core preferences stated with clear emphasis ("I always prefer...", "I never want...")
+- Important ongoing projects or goals mentioned multiple times
+- Persistent technical constraints or requirements
+- Domain expertise demonstrated consistently
+- Custom terminology the user defines and uses repeatedly
+
+**DO NOT EXTRACT** - Facts that are:
+- One-time requests or isolated tasks (e.g., "generate an image or similar")
+- Single interactions without pattern repetition
+- Casual preferences from single occurrences
+- Testing or exploratory questions
+- Temporary context or transient information
+- General courtesy or social patterns (greetings, thank yous)
+- Random or playful requests that don't indicate lasting preference
+- Information that could change or is situational
+
+# Quality Standards
+- **Confidence threshold**: Only extract if confidence >= 0.8
+- **Persistence required**: Must see evidence across multiple messages or strong explicit statement
+- **Meaningful value**: Would this fact improve future interactions weeks from now?
+- **Not redundant**: Avoid if existing memories already cover this information
+
 # Instructions
-Extract any NEW information that should be remembered long-term. For each item:
+Extract ONLY truly important NEW information that meets the strict criteria above. For each item:
 - Determine which category it belongs to
 - Write a clear, factual statement
-- Assess confidence (0.0 to 1.0)
-- Only include information explicitly stated or strongly implied
+- Assess confidence (0.0 to 1.0) - BE CONSERVATIVE
+- Require strong evidence before extraction
+
+**When in doubt, DO NOT extract.** It's better to miss temporary information than to clutter long-term memory.
 
 If there are no new long-term facts to extract, respond with <memories></memories>
 
@@ -891,7 +981,7 @@ var shortTermMemoryProvider = {
       if (!memoryService) {
         return {
           data: { summaries: [], recentMessages: [], mode: "disabled" },
-          values: { sessionSummaries: "", recentMessages: "" },
+          values: {},
           text: ""
         };
       }
@@ -972,9 +1062,7 @@ ${runText}`;
               mode: "full_conversation"
             },
             values: {
-              sessionSummaries: "",
-              recentMessages: "",
-              recentActionResults: ""
+              recentMessage: "No recent message available."
             },
             text: "No recent messages available"
           };
@@ -1012,10 +1100,14 @@ ${runText}`;
             mode: "full_conversation"
           },
           values: {
-            sessionSummaries: "",
-            recentMessages: isPostFormat ? recentPosts : recentMessages,
-            recentActionResults: actionResultsText,
-            recentMessage
+            ...(isPostFormat ? recentPosts : recentMessages) && {
+              recentMessages: isPostFormat ? recentPosts : recentMessages
+            },
+            ...recentPosts && { recentPosts },
+            ...actionResultsText && { recentActionResults: actionResultsText },
+            ...recentMessage && { recentMessage },
+            ...receivedMessageHeader && { receivedMessageHeader },
+            ...focusHeader && { focusHeader }
           },
           text: text4
         };
@@ -1085,8 +1177,10 @@ ${runText}`;
             mode: "summarized"
           },
           values: {
-            sessionSummaries: summaryText,
-            recentMessages: recentMessagesText
+            ...summaryText && { sessionSummaries: summaryText },
+            ...recentMessagesText && { recentMessages: recentMessagesText },
+            ...receivedMessageHeader && { receivedMessageHeader },
+            ...focusHeader && { focusHeader }
           },
           text: text4
         };
@@ -1095,7 +1189,7 @@ ${runText}`;
       import_core4.logger.error({ error }, "Error in shortTermMemoryProvider:");
       return {
         data: { summaries: [], recentMessages: [], mode: "error" },
-        values: { sessionSummaries: "", recentMessages: "" },
+        values: {},
         text: "Error retrieving conversation context."
       };
     }
@@ -1175,4 +1269,4 @@ var memoryPlugin = {
 };
 var src_default = memoryPlugin;
 
-//# debugId=965D3FAC4FCE781C64756E2164756E21
+//# debugId=3C20A9F0BA14039464756E2164756E21