@elizaos/plugin-memory 1.0.5 → 1.0.6

package/dist/cjs/index.node.cjs

@@ -127,13 +127,13 @@ class MemoryService extends import_core.Service {
     this.lastExtractionCheckpoints = new Map;
     this.memoryConfig = {
       shortTermSummarizationThreshold: 16,
-      shortTermRetainRecent: 10,
+      shortTermRetainRecent: 6,
       shortTermSummarizationInterval: 10,
       longTermExtractionEnabled: true,
       longTermVectorSearchEnabled: false,
-      longTermConfidenceThreshold: 0.7,
-      longTermExtractionThreshold: 20,
-      longTermExtractionInterval: 5,
+      longTermConfidenceThreshold: 0.85,
+      longTermExtractionThreshold: 30,
+      longTermExtractionInterval: 10,
       summaryModelType: "TEXT_LARGE",
       summaryMaxTokens: 2500,
       summaryMaxNewMessages: 20
@@ -771,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 ONLY the most important, persistent facts about the user that should be remembered long-term.
+You are analyzing a conversation to extract ONLY the most critical, persistent information about the user using cognitive science memory categories.
 
 # Recent Messages
 {{recentMessages}}
@@ -793,66 +787,127 @@ You are analyzing a conversation to extract ONLY the most important, persistent
 # 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)
 
-# STRICT EXTRACTION CRITERIA
+## 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"
 
-**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
+**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
 
-**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
+## 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"
 
-# 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
+**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
 
-# Instructions
-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) - BE CONSERVATIVE
-- Require strong evidence before extraction
+## 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"
 
-**When in doubt, DO NOT extract.** It's better to miss temporary information than to clutter long-term memory.
+**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
 
-If there are no new long-term facts to extract, respond with <memories></memories>
+# 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) {
@@ -941,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,
@@ -956,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");
@@ -971,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({
@@ -998,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"));
@@ -1014,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;
@@ -1022,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));
@@ -1058,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"
           };
@@ -1084,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,
@@ -1093,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,
@@ -1143,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`;
@@ -1162,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(`
@@ -1173,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 }
           },
@@ -1188,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."
       };
     }
@@ -1269,4 +1564,4 @@ var memoryPlugin = {
 };
 var src_default = memoryPlugin;
 
-//# debugId=3C20A9F0BA14039464756E2164756E21
+//# debugId=A3C66779A69339CA64756E2164756E21