@elizaos/plugin-memory 1.0.4 → 1.0.6

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,
-      shortTermRetainRecent: 10,
+      shortTermSummarizationThreshold: 16,
+      shortTermRetainRecent: 6,
+      shortTermSummarizationInterval: 10,
       longTermExtractionEnabled: true,
       longTermVectorSearchEnabled: false,
-      longTermConfidenceThreshold: 0.7,
-      longTermExtractionInterval: 5,
+      longTermConfidenceThreshold: 0.85,
+      longTermExtractionThreshold: 30,
+      longTermExtractionInterval: 10,
       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,
@@ -710,21 +771,15 @@ var import_core3 = require("@elizaos/core");
 // src/types/index.ts
 var LongTermMemoryCategory;
 ((LongTermMemoryCategory2) => {
-  LongTermMemoryCategory2["IDENTITY"] = "identity";
-  LongTermMemoryCategory2["EXPERTISE"] = "expertise";
-  LongTermMemoryCategory2["PROJECTS"] = "projects";
-  LongTermMemoryCategory2["PREFERENCES"] = "preferences";
-  LongTermMemoryCategory2["DATA_SOURCES"] = "data_sources";
-  LongTermMemoryCategory2["GOALS"] = "goals";
-  LongTermMemoryCategory2["CONSTRAINTS"] = "constraints";
-  LongTermMemoryCategory2["DEFINITIONS"] = "definitions";
-  LongTermMemoryCategory2["BEHAVIORAL_PATTERNS"] = "behavioral_patterns";
+  LongTermMemoryCategory2["EPISODIC"] = "episodic";
+  LongTermMemoryCategory2["SEMANTIC"] = "semantic";
+  LongTermMemoryCategory2["PROCEDURAL"] = "procedural";
 })(LongTermMemoryCategory ||= {});
 
 // src/evaluators/long-term-extraction.ts
-var extractionTemplate = `# Task: Extract Long-Term Memory
+var extractionTemplate = `# Task: Extract Long-Term Memory (Strict Criteria)
 
-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 critical, persistent information about the user using cognitive science memory categories.
 
 # Recent Messages
 {{recentMessages}}
@@ -732,37 +787,127 @@ You are analyzing a conversation to extract facts that should be remembered long
 # Current Long-Term Memories
 {{existingMemories}}
 
-# Memory Categories
-1. **identity**: User's name, role, identity (e.g., "I'm a data scientist")
-2. **expertise**: User's skills, knowledge domains, or unfamiliarity with topics
-3. **projects**: Ongoing projects, past interactions, recurring topics
-4. **preferences**: Communication style, format preferences, verbosity, etc.
-5. **data_sources**: Frequently used files, databases, APIs
-6. **goals**: Broader intentions (e.g., "preparing for interview")
-7. **constraints**: User-defined rules or limitations
-8. **definitions**: Custom terms, acronyms, glossaries
-9. **behavioral_patterns**: How the user tends to interact
+# Memory Categories (Based on Cognitive Science)
 
-# Instructions
-Extract any NEW information that should be remembered long-term. 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
+## 1. EPISODIC Memory
+Personal experiences and specific events with temporal/spatial context.
+**Examples:**
+- "User completed migration project from MongoDB to PostgreSQL in Q2 2024"
+- "User encountered authentication bug in production on March 15th"
+- "User had a negative experience with Docker networking in previous job"
 
-If there are no new long-term facts to extract, respond with <memories></memories>
+**Requirements:**
+- Must include WHO did WHAT, WHEN/WHERE
+- Must be a specific, concrete event (not a pattern)
+- Must have significant impact or relevance to future work
+
+## 2. SEMANTIC Memory
+General facts, concepts, knowledge, and established truths about the user.
+**Examples:**
+- "User is a senior backend engineer with 8 years experience"
+- "User specializes in distributed systems and microservices architecture"
+- "User's primary programming language is TypeScript"
+- "User works at Acme Corp as technical lead"
+
+**Requirements:**
+- Must be factual, timeless information
+- Must be explicitly stated or demonstrated conclusively
+- No speculation or inference from single instances
+- Core identity, expertise, or knowledge only
+
+## 3. PROCEDURAL Memory
+Skills, workflows, methodologies, and how-to knowledge.
+**Examples:**
+- "User follows strict TDD workflow: write tests first, then implementation"
+- "User prefers git rebase over merge to maintain linear history"
+- "User's debugging process: check logs → reproduce locally → binary search"
+- "User always writes JSDoc comments before implementing functions"
+
+**Requirements:**
+- Must describe HOW user does something
+- Must be a repeated, consistent pattern (seen 3+ times or explicitly stated as standard practice)
+- Must be a workflow, methodology, or skill application
+- Not one-off preferences
+
+# ULTRA-STRICT EXTRACTION CRITERIA
+
+## ✅ DO EXTRACT (Only These):
+
+**EPISODIC:**
+- Significant completed projects or milestones
+- Important bugs, incidents, or problems encountered
+- Major decisions made with lasting impact
+- Formative experiences that shape future work
+
+**SEMANTIC:**
+- Professional identity (role, title, company)
+- Core expertise and specializations (stated explicitly or demonstrated conclusively)
+- Primary languages, frameworks, or tools (not exploratory use)
+- Established facts about their work context
+
+**PROCEDURAL:**
+- Consistent workflows demonstrated 3+ times or explicitly stated
+- Standard practices user always follows
+- Methodology preferences with clear rationale
+- Debugging, testing, or development processes
+
+## ❌ NEVER EXTRACT:
+
+- **One-time requests or tasks** (e.g., "can you generate an image", "help me debug this")
+- **Casual conversations** without lasting significance
+- **Exploratory questions** (e.g., "how does X work?")
+- **Temporary context** (current bug, today's task)
+- **Preferences from single occurrence** (e.g., user asked for code once)
+- **Social pleasantries** (thank you, greetings)
+- **Testing or experimentation** (trying out a feature)
+- **Common patterns everyone has** (likes clear explanations)
+- **Situational information** (working on feature X today)
+- **Opinions without persistence** (single complaint, isolated praise)
+- **General knowledge** (not specific to user)
+
+# Quality Gates (ALL Must Pass)
+
+1. **Significance Test**: Will this matter in 3+ months?
+2. **Specificity Test**: Is this concrete and actionable?
+3. **Evidence Test**: Is there strong evidence (3+ instances OR explicit self-identification)?
+4. **Uniqueness Test**: Is this specific to THIS user (not generic)?
+5. **Confidence Test**: Confidence must be >= 0.85 (be VERY conservative)
+6. **Non-Redundancy Test**: Does this add NEW information not in existing memories?
+
+# Confidence Scoring (Be Conservative)
+
+- **0.95-1.0**: User explicitly stated as core identity/practice AND demonstrated multiple times
+- **0.85-0.94**: User explicitly stated OR consistently demonstrated 5+ times
+- **0.75-0.84**: Strong pattern (3-4 instances) with supporting context
+- **Below 0.75**: DO NOT EXTRACT (insufficient evidence)
+
+# Critical Instructions
+
+1. **Default to NOT extracting** - When in doubt, skip it
+2. **Require overwhelming evidence** - One or two mentions is NOT enough
+3. **Focus on what's PERSISTENT** - Not what's temporary or situational
+4. **Verify against existing memories** - Don't duplicate or contradict
+5. **Maximum 2-3 extractions per run** - Quality over quantity
+
+**If there are no qualifying facts (which is common), respond with <memories></memories>**
+
+# Response Format
 
-Respond in this XML format:
 <memories>
   <memory>
-    <category>identity</category>
-    <content>User is a software engineer specializing in backend development</content>
+    <category>semantic</category>
+    <content>User is a senior TypeScript developer with 8 years of backend experience</content>
     <confidence>0.95</confidence>
   </memory>
   <memory>
-    <category>preferences</category>
-    <content>Prefers code examples over lengthy explanations</content>
-    <confidence>0.85</confidence>
+    <category>procedural</category>
+    <content>User follows TDD workflow: writes tests before implementation, runs tests after each change</content>
+    <confidence>0.88</confidence>
+  </memory>
+  <memory>
+    <category>episodic</category>
+    <content>User led database migration from MongoDB to PostgreSQL for payment system in Q2 2024</content>
+    <confidence>0.92</confidence>
   </memory>
 </memories>`;
 function parseMemoryExtractionXML(xml) {
@@ -851,7 +996,7 @@ var longTermExtractionEvaluator = {
       const extractions = parseMemoryExtractionXML(response);
       import_core3.logger.info(`Extracted ${extractions.length} long-term memories`);
       for (const extraction of extractions) {
-        if (extraction.confidence >= config.longTermConfidenceThreshold) {
+        if (extraction.confidence >= Math.max(config.longTermConfidenceThreshold, 0.85)) {
           await memoryService.storeLongTermMemory({
             agentId: runtime.agentId,
             entityId,
@@ -866,7 +1011,7 @@ var longTermExtractionEvaluator = {
           });
           import_core3.logger.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
         } else {
-          import_core3.logger.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
+          import_core3.logger.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence}, threshold: ${Math.max(config.longTermConfidenceThreshold, 0.85)})`);
         }
       }
       const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
@@ -881,26 +1026,31 @@ var longTermExtractionEvaluator = {
 
 // src/providers/short-term-memory.ts
 var import_core4 = require("@elizaos/core");
+var getRecentInteractions = async (runtime, sourceEntityId, targetEntityId, excludeRoomId) => {
+  const rooms = await runtime.getRoomsForParticipants([sourceEntityId, targetEntityId]);
+  return runtime.getMemoriesByRoomIds({
+    tableName: "messages",
+    roomIds: rooms.filter((room) => room !== excludeRoomId),
+    limit: 20
+  });
+};
 var shortTermMemoryProvider = {
   name: "SHORT_TERM_MEMORY",
-  description: "Adaptive conversation context with smart summarization",
+  description: "Unified conversation context with smart summarization and interactions",
   position: 95,
   get: async (runtime, message, _state) => {
     try {
       const memoryService = runtime.getService("memory");
-      if (!memoryService) {
-        return {
-          data: { summaries: [], recentMessages: [], mode: "disabled" },
-          values: {},
-          text: ""
-        };
-      }
       const { roomId } = message;
-      const config = memoryService.getConfig();
+      const conversationLength = 16;
+      const config = memoryService?.getConfig() || {
+        shortTermSummarizationThreshold: 16,
+        shortTermRetainRecent: 6
+      };
       const totalMessageCount = await runtime.countMemories(roomId, false, "messages");
-      if (totalMessageCount < config.shortTermSummarizationThreshold) {
-        const conversationLength = runtime.getConversationLength();
-        const [entitiesData, room, recentMessagesData] = await Promise.all([
+      const useSummarization = memoryService && totalMessageCount >= config.shortTermSummarizationThreshold;
+      if (!useSummarization) {
+        const [entitiesData, room, recentMessagesData, recentInteractionsData] = await Promise.all([
           import_core4.getEntityDetails({ runtime, roomId }),
           runtime.getRoom(roomId),
           runtime.getMemories({
@@ -908,7 +1058,8 @@ var shortTermMemoryProvider = {
             roomId,
             count: conversationLength,
             unique: false
-          })
+          }),
+          message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
         ]);
         const actionResultMessages = recentMessagesData.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
         const dialogueMessages = recentMessagesData.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
@@ -924,6 +1075,20 @@ var shortTermMemoryProvider = {
             conversationHeader: false
           })
         ]);
+        const formatConversationLog = (messages, includeThoughts) => {
+          return messages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0)).map((msg) => {
+            const entity = entitiesData.find((e) => e.id === msg.entityId);
+            const entityName = entity?.names[0] || (msg.entityId === runtime.agentId ? runtime.character.name : "Unknown");
+            const timestamp4 = msg.createdAt ? new Date(msg.createdAt).toLocaleString() : "Unknown time";
+            const text5 = msg.content.text || "";
+            const thought = includeThoughts && msg.content.internalMonologue ? `
+  [Internal thought: ${msg.content.internalMonologue}]` : "";
+            return `[${timestamp4}] ${entityName}: ${text5}${thought}`;
+          }).join(`
+`);
+        };
+        const conversationLog = formatConversationLog(dialogueMessages, false);
+        const conversationLogWithAgentThoughts = formatConversationLog(dialogueMessages, true);
         let actionResultsText = "";
         if (actionResultMessages.length > 0) {
           const groupedByRun = new Map;
@@ -932,7 +1097,10 @@ var shortTermMemoryProvider = {
             if (!groupedByRun.has(runId)) {
               groupedByRun.set(runId, []);
             }
-            groupedByRun.get(runId)?.push(mem);
+            const memories = groupedByRun.get(runId);
+            if (memories) {
+              memories.push(mem);
+            }
           }
           const formattedActionResults = Array.from(groupedByRun.entries()).slice(-3).map(([runId, memories]) => {
             const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
@@ -968,11 +1136,20 @@ ${runText}`;
             data: {
               summaries: [],
               recentMessages: [],
+              recentInteractions: [],
               actionResults: [],
               mode: "full_conversation"
             },
             values: {
-              recentMessage: "No recent message available."
+              recentPosts: "",
+              recentMessages: "",
+              recentMessageInteractions: "",
+              recentPostInteractions: "",
+              recentInteractions: "",
+              recentActionResults: "",
+              recentMessage: "No recent message available.",
+              conversationLog: "",
+              conversationLogWithAgentThoughts: ""
             },
             text: "No recent messages available"
           };
@@ -994,6 +1171,80 @@ ${runText}`;
         const hasReceivedMessage = !!receivedMessageContent?.trim();
         const receivedMessageHeader = hasReceivedMessage ? import_core4.addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
         const focusHeader = hasReceivedMessage ? import_core4.addHeader("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message. Do not repeat earlier replies unless the sender asks again.`) : "";
+        const interactionEntityMap = new Map;
+        if (recentInteractionsData.length > 0) {
+          const uniqueEntityIds = [
+            ...new Set(recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId))
+          ];
+          const uniqueEntityIdSet = new Set(uniqueEntityIds);
+          const entitiesDataIdSet = new Set;
+          entitiesData.forEach((entity) => {
+            if (uniqueEntityIdSet.has(entity.id)) {
+              interactionEntityMap.set(entity.id, entity);
+              entitiesDataIdSet.add(entity.id);
+            }
+          });
+          const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
+          if (remainingEntityIds.length > 0) {
+            const entities = await Promise.all(remainingEntityIds.map((entityId) => runtime.getEntityById(entityId)));
+            entities.forEach((entity, index4) => {
+              if (entity) {
+                interactionEntityMap.set(remainingEntityIds[index4], entity);
+              }
+            });
+          }
+        }
+        const getRecentMessageInteractions = async (recentInteractionsData2) => {
+          const formattedInteractions = recentInteractionsData2.map((message2) => {
+            const isSelf = message2.entityId === runtime.agentId;
+            let sender;
+            if (isSelf) {
+              sender = runtime.character.name;
+            } else {
+              sender = interactionEntityMap.get(message2.entityId)?.metadata?.userName || "unknown";
+            }
+            return `${sender}: ${message2.content.text}`;
+          });
+          return formattedInteractions.join(`
+`);
+        };
+        const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
+          const combinedEntities = [...entities];
+          const actorIds = new Set(entities.map((entity) => entity.id));
+          for (const [id, entity] of interactionEntityMap.entries()) {
+            if (!actorIds.has(id)) {
+              combinedEntities.push(entity);
+            }
+          }
+          const formattedInteractions = import_core4.formatPosts({
+            messages: recentInteractionsData2,
+            entities: combinedEntities,
+            conversationHeader: true
+          });
+          return formattedInteractions;
+        };
+        const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
+          getRecentMessageInteractions(recentInteractionsData),
+          getRecentPostInteractions(recentInteractionsData, entitiesData)
+        ]);
+        const data = {
+          summaries: [],
+          recentMessages: dialogueMessages,
+          recentInteractions: recentInteractionsData,
+          actionResults: actionResultMessages,
+          mode: "full_conversation"
+        };
+        const values = {
+          recentPosts,
+          recentMessages,
+          recentMessageInteractions,
+          recentPostInteractions,
+          recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions,
+          recentActionResults: actionResultsText,
+          recentMessage,
+          conversationLog,
+          conversationLogWithAgentThoughts
+        };
         const text4 = [
           isPostFormat ? recentPosts : recentMessages,
           actionResultsText,
@@ -1003,40 +1254,68 @@ ${runText}`;
 
 `);
         return {
-          data: {
-            summaries: [],
-            recentMessages: dialogueMessages,
-            actionResults: actionResultMessages,
-            mode: "full_conversation"
-          },
-          values: {
-            ...(isPostFormat ? recentPosts : recentMessages) && {
-              recentMessages: isPostFormat ? recentPosts : recentMessages
-            },
-            ...recentPosts && { recentPosts },
-            ...actionResultsText && { recentActionResults: actionResultsText },
-            ...recentMessage && { recentMessage },
-            ...receivedMessageHeader && { receivedMessageHeader },
-            ...focusHeader && { focusHeader }
-          },
+          data,
+          values,
           text: text4
         };
       } else {
         const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
         const lastOffset = currentSummary?.lastMessageOffset || 0;
-        const unsummarizedMessages = await runtime.getMemories({
-          tableName: "messages",
-          roomId,
-          count: config.shortTermRetainRecent,
-          unique: false,
-          start: lastOffset
-        });
-        const entitiesData = await import_core4.getEntityDetails({ runtime, roomId });
-        const room = await runtime.getRoom(roomId);
+        const recentCount = config.shortTermRetainRecent;
+        const [entitiesData, room, unsummarizedMessages, recentInteractionsData] = await Promise.all([
+          import_core4.getEntityDetails({ runtime, roomId }),
+          runtime.getRoom(roomId),
+          runtime.getMemories({
+            tableName: "messages",
+            roomId,
+            count: recentCount,
+            unique: false,
+            start: lastOffset
+          }),
+          message.entityId !== runtime.agentId ? getRecentInteractions(runtime, message.entityId, runtime.agentId, roomId) : Promise.resolve([])
+        ]);
         const isPostFormat = room?.type ? room.type === import_core4.ChannelType.FEED || room.type === import_core4.ChannelType.THREAD : false;
+        const actionResultMessages = unsummarizedMessages.filter((msg) => msg.content?.type === "action_result" && msg.metadata?.type === "action_result");
+        const dialogueMessages = unsummarizedMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
+        let actionResultsText = "";
+        if (actionResultMessages.length > 0) {
+          const groupedByRun = new Map;
+          for (const mem of actionResultMessages) {
+            const runId = String(mem.content?.runId || "unknown");
+            if (!groupedByRun.has(runId)) {
+              groupedByRun.set(runId, []);
+            }
+            groupedByRun.get(runId)?.push(mem);
+          }
+          const formattedActionResults = Array.from(groupedByRun.entries()).slice(-3).map(([runId, memories]) => {
+            const sortedMemories = memories.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+            const thought = sortedMemories[0]?.content?.planThought || "";
+            const runText = sortedMemories.map((mem) => {
+              const actionName = mem.content?.actionName || "Unknown";
+              const status = mem.content?.actionStatus || "unknown";
+              const planStep = mem.content?.planStep || "";
+              const text5 = mem.content?.text || "";
+              const error = mem.content?.error || "";
+              let memText = `  - ${actionName} (${status})`;
+              if (planStep)
+                memText += ` [${planStep}]`;
+              if (error) {
+                memText += `: Error - ${error}`;
+              } else if (text5 && text5 !== `Executed action: ${actionName}`) {
+                memText += `: ${text5}`;
+              }
+              return memText;
+            }).join(`
+`);
+            return `**Action Run ${runId.slice(0, 8)}**${thought ? ` - "${thought}"` : ""}
+${runText}`;
+          }).join(`
+
+`);
+          actionResultsText = formattedActionResults ? import_core4.addHeader("# Recent Action Executions", formattedActionResults) : "";
+        }
         let recentMessagesText = "";
-        if (unsummarizedMessages.length > 0) {
-          const dialogueMessages = unsummarizedMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
+        if (dialogueMessages.length > 0) {
           if (isPostFormat) {
             recentMessagesText = import_core4.formatPosts({
               messages: dialogueMessages,
@@ -1053,6 +1332,31 @@ ${runText}`;
             recentMessagesText = import_core4.addHeader("# Recent Messages", recentMessagesText);
           }
         }
+        let recentMessage = "No recent message available.";
+        if (dialogueMessages.length > 0) {
+          const mostRecentMessage = [...dialogueMessages].sort((a, b) => (b.createdAt || 0) - (a.createdAt || 0))[0];
+          const formattedSingleMessage = import_core4.formatMessages({
+            messages: [mostRecentMessage],
+            entities: entitiesData
+          });
+          if (formattedSingleMessage) {
+            recentMessage = formattedSingleMessage;
+          }
+        }
+        const formatConversationLog = (messages, includeThoughts) => {
+          return messages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0)).map((msg) => {
+            const entity = entitiesData.find((e) => e.id === msg.entityId);
+            const entityName = entity?.names[0] || (msg.entityId === runtime.agentId ? runtime.character.name : "Unknown");
+            const timestamp4 = msg.createdAt ? new Date(msg.createdAt).toLocaleString() : "Unknown time";
+            const text5 = msg.content.text || "";
+            const thought = includeThoughts && msg.content.internalMonologue ? `
+  [Internal thought: ${msg.content.internalMonologue}]` : "";
+            return `[${timestamp4}] ${entityName}: ${text5}${thought}`;
+          }).join(`
+`);
+        };
+        const conversationLog = formatConversationLog(dialogueMessages, false);
+        const conversationLogWithAgentThoughts = formatConversationLog(dialogueMessages, true);
         let summaryText = "";
         if (currentSummary) {
           const messageRange = `${currentSummary.messageCount} messages`;
@@ -1072,9 +1376,66 @@ ${runText}`;
         const hasReceivedMessage = !!receivedMessageContent?.trim();
         const receivedMessageHeader = hasReceivedMessage ? import_core4.addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
         const focusHeader = hasReceivedMessage ? import_core4.addHeader("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message.`) : "";
+        const interactionEntityMap = new Map;
+        if (recentInteractionsData.length > 0) {
+          const uniqueEntityIds = [
+            ...new Set(recentInteractionsData.map((message2) => message2.entityId).filter((id) => id !== runtime.agentId))
+          ];
+          const uniqueEntityIdSet = new Set(uniqueEntityIds);
+          const entitiesDataIdSet = new Set;
+          entitiesData.forEach((entity) => {
+            if (uniqueEntityIdSet.has(entity.id)) {
+              interactionEntityMap.set(entity.id, entity);
+              entitiesDataIdSet.add(entity.id);
+            }
+          });
+          const remainingEntityIds = uniqueEntityIds.filter((id) => !entitiesDataIdSet.has(id));
+          if (remainingEntityIds.length > 0) {
+            const entities = await Promise.all(remainingEntityIds.map((entityId) => runtime.getEntityById(entityId)));
+            entities.forEach((entity, index4) => {
+              if (entity) {
+                interactionEntityMap.set(remainingEntityIds[index4], entity);
+              }
+            });
+          }
+        }
+        const getRecentMessageInteractions = async (recentInteractionsData2) => {
+          const formattedInteractions = recentInteractionsData2.map((message2) => {
+            const isSelf = message2.entityId === runtime.agentId;
+            let sender;
+            if (isSelf) {
+              sender = runtime.character.name;
+            } else {
+              sender = interactionEntityMap.get(message2.entityId)?.metadata?.userName || "unknown";
+            }
+            return `${sender}: ${message2.content.text}`;
+          });
+          return formattedInteractions.join(`
+`);
+        };
+        const getRecentPostInteractions = async (recentInteractionsData2, entities) => {
+          const combinedEntities = [...entities];
+          const actorIds = new Set(entities.map((entity) => entity.id));
+          for (const [id, entity] of interactionEntityMap.entries()) {
+            if (!actorIds.has(id)) {
+              combinedEntities.push(entity);
+            }
+          }
+          const formattedInteractions = import_core4.formatPosts({
+            messages: recentInteractionsData2,
+            entities: combinedEntities,
+            conversationHeader: true
+          });
+          return formattedInteractions;
+        };
+        const [recentMessageInteractions, recentPostInteractions] = await Promise.all([
+          getRecentMessageInteractions(recentInteractionsData),
+          getRecentPostInteractions(recentInteractionsData, entitiesData)
+        ]);
         const text4 = [
           summaryText,
           recentMessagesText,
+          actionResultsText,
           hasReceivedMessage ? receivedMessageHeader : "",
           hasReceivedMessage ? focusHeader : ""
         ].filter(Boolean).join(`
@@ -1083,12 +1444,21 @@ ${runText}`;
         return {
           data: {
             summaries: currentSummary ? [currentSummary] : [],
-            recentMessages: unsummarizedMessages,
+            recentMessages: dialogueMessages,
+            recentInteractions: recentInteractionsData,
+            actionResults: actionResultMessages,
             mode: "summarized"
           },
           values: {
             ...summaryText && { sessionSummaries: summaryText },
             ...recentMessagesText && { recentMessages: recentMessagesText },
+            recentMessageInteractions,
+            recentPostInteractions,
+            recentInteractions: isPostFormat ? recentPostInteractions : recentMessageInteractions,
+            ...actionResultsText && { recentActionResults: actionResultsText },
+            recentMessage,
+            conversationLog,
+            conversationLogWithAgentThoughts,
             ...receivedMessageHeader && { receivedMessageHeader },
             ...focusHeader && { focusHeader }
           },
@@ -1098,8 +1468,23 @@ ${runText}`;
     } catch (error) {
       import_core4.logger.error({ error }, "Error in shortTermMemoryProvider:");
       return {
-        data: { summaries: [], recentMessages: [], mode: "error" },
-        values: {},
+        data: {
+          summaries: [],
+          recentMessages: [],
+          recentInteractions: [],
+          actionResults: [],
+          mode: "error"
+        },
+        values: {
+          recentPosts: "",
+          recentMessages: "",
+          recentMessageInteractions: "",
+          recentPostInteractions: "",
+          recentInteractions: "",
+          recentActionResults: "",
+          conversationLog: "",
+          conversationLogWithAgentThoughts: ""
+        },
         text: "Error retrieving conversation context."
       };
     }
@@ -1179,4 +1564,4 @@ var memoryPlugin = {
 };
 var src_default = memoryPlugin;
 
-//# debugId=DC07601B16F2760064756E2164756E21
+//# debugId=A3C66779A69339CA64756E2164756E21