@elizaos/plugin-memory 1.0.5 → 1.0.7

package/dist/cjs/index.node.cjs

@@ -30,10 +30,13 @@ var __export = (target, all) => {
 var exports_index_node = {};
 __export(exports_index_node, {
   sessionSummaries: () => sessionSummaries,
+  recentMessagesProvider: () => recentMessagesProvider,
   memoryPlugin: () => memoryPlugin,
   memoryAccessLogs: () => memoryAccessLogs,
+  longTermMemoryProvider: () => longTermMemoryProvider,
   longTermMemories: () => longTermMemories,
   default: () => src_default,
+  contextSummaryProvider: () => contextSummaryProvider,
   MemoryService: () => MemoryService,
   LongTermMemoryCategory: () => LongTermMemoryCategory
 });
@@ -127,13 +130,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
@@ -183,7 +186,7 @@ class MemoryService extends import_core.Service {
     if (extractionInterval) {
       this.memoryConfig.longTermExtractionInterval = parseInt(extractionInterval, 10);
     }
-    import_core.logger.info({
+    import_core.logger.debug({
       summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
       summarizationInterval: this.memoryConfig.shortTermSummarizationInterval,
       maxNewMessages: this.memoryConfig.summaryMaxNewMessages,
@@ -540,6 +543,16 @@ ${items}`);
 
 // src/evaluators/summarization.ts
 var import_core2 = require("@elizaos/core");
+async function getDialogueMessageCount(runtime, roomId) {
+  const messages = await runtime.getMemories({
+    tableName: "messages",
+    roomId,
+    count: 100,
+    unique: false
+  });
+  const dialogueMessages = messages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
+  return dialogueMessages.length;
+}
 var initialSummarizationTemplate = `# Task: Summarize Conversation
 
 You are analyzing a conversation to create a concise summary that captures the key points, topics, and important details.
@@ -627,26 +640,26 @@ var summarizationEvaluator = {
       return false;
     }
     const config = memoryService.getConfig();
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
+    const currentDialogueCount = await getDialogueMessageCount(runtime, message.roomId);
     const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
     if (!existingSummary) {
-      const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
+      const shouldSummarize = currentDialogueCount >= config.shortTermSummarizationThreshold;
       import_core2.logger.debug({
         roomId: message.roomId,
-        currentMessageCount,
+        currentDialogueCount,
         threshold: config.shortTermSummarizationThreshold,
         shouldSummarize,
         reason: "initial_summary_check"
       }, "Summarization validation check");
       return shouldSummarize;
     } else {
-      const newMessageCount = currentMessageCount - existingSummary.lastMessageOffset;
-      const shouldUpdate = newMessageCount >= config.shortTermSummarizationInterval;
+      const newDialogueCount = currentDialogueCount - existingSummary.lastMessageOffset;
+      const shouldUpdate = newDialogueCount >= config.shortTermSummarizationInterval;
       import_core2.logger.debug({
         roomId: message.roomId,
-        currentMessageCount,
+        currentDialogueCount,
         lastOffset: existingSummary.lastMessageOffset,
-        newMessageCount,
+        newDialogueCount,
         interval: config.shortTermSummarizationInterval,
         shouldUpdate,
         reason: "summary_update_check"
@@ -666,30 +679,31 @@ var summarizationEvaluator = {
       import_core2.logger.info(`Starting summarization for room ${roomId}`);
       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({
+      const allMessages = await runtime.getMemories({
         tableName: "messages",
         roomId,
-        count: messagesToFetch,
-        unique: false,
-        start: lastOffset
+        count: 1000,
+        unique: false
       });
-      if (newMessages.length === 0) {
-        import_core2.logger.debug("No new messages retrieved");
+      const allDialogueMessages = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
+      const totalDialogueCount = allDialogueMessages.length;
+      const newDialogueCount = totalDialogueCount - lastOffset;
+      if (newDialogueCount === 0) {
+        import_core2.logger.debug("No new dialogue messages to summarize");
         return;
       }
-      const sortedMessages = newMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const formattedMessages = sortedMessages.map((msg) => {
+      const maxNewMessages = config.summaryMaxNewMessages || 50;
+      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
+      if (newDialogueCount > maxNewMessages) {
+        import_core2.logger.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available). Oldest messages will be skipped.`);
+      }
+      const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+      const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
+      if (newDialogueMessages.length === 0) {
+        import_core2.logger.debug("No new dialogue messages retrieved after filtering");
+        return;
+      }
+      const formattedMessages = newDialogueMessages.map((msg) => {
         const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
         return `${sender}: ${msg.content.text || "[non-text message]"}`;
       }).join(`
@@ -709,11 +723,16 @@ var summarizationEvaluator = {
           template
         });
       } else {
+        const initialMessages = sortedDialogueMessages.map((msg) => {
+          const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
+          return `${sender}: ${msg.content.text || "[non-text message]"}`;
+        }).join(`
+`);
         template = initialSummarizationTemplate;
         prompt = import_core2.composePromptFromState({
           state: {
             ...state,
-            recentMessages: formattedMessages
+            recentMessages: initialMessages
           },
           template
         });
@@ -724,15 +743,15 @@ var summarizationEvaluator = {
       });
       const summaryResult = parseSummaryXML(response);
       import_core2.logger.info(`${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
-      const newOffset = totalMessageCount;
-      const firstMessage = sortedMessages[0];
-      const lastMessage = sortedMessages[sortedMessages.length - 1];
+      const newOffset = lastOffset + newDialogueMessages.length;
+      const firstMessage = newDialogueMessages[0];
+      const lastMessage = newDialogueMessages[newDialogueMessages.length - 1];
       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, roomId, {
           summary: summaryResult.summary,
-          messageCount: existingSummary.messageCount + sortedMessages.length,
+          messageCount: existingSummary.messageCount + newDialogueMessages.length,
           lastMessageOffset: newOffset,
           endTime,
           topics: summaryResult.topics,
@@ -740,15 +759,15 @@ var summarizationEvaluator = {
             keyPoints: summaryResult.keyPoints
           }
         });
-        import_core2.logger.info(`Updated summary for room ${roomId}: ${sortedMessages.length} new messages processed (offset: ${lastOffset} → ${newOffset})`);
+        import_core2.logger.info(`Updated summary for room ${roomId}: ${newDialogueMessages.length} new dialogue messages processed (offset: ${lastOffset} → ${newOffset})`);
       } else {
         await memoryService.storeSessionSummary({
           agentId: runtime.agentId,
           roomId,
           entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
           summary: summaryResult.summary,
-          messageCount: sortedMessages.length,
-          lastMessageOffset: newOffset,
+          messageCount: totalDialogueCount,
+          lastMessageOffset: totalDialogueCount,
           startTime,
           endTime,
           topics: summaryResult.topics,
@@ -756,7 +775,7 @@ var summarizationEvaluator = {
             keyPoints: summaryResult.keyPoints
           }
         });
-        import_core2.logger.info(`Created new summary for room ${roomId}: ${sortedMessages.length} messages summarized (offset: 0 → ${newOffset})`);
+        import_core2.logger.info(`Created new summary for room ${roomId}: ${totalDialogueCount} dialogue messages summarized (offset: 0 → ${totalDialogueCount})`);
       }
     } catch (error) {
       import_core2.logger.error({ error }, "Error during summarization:");
@@ -771,21 +790,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 +806,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 +1015,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 +1030,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");
@@ -969,235 +1043,8 @@ var longTermExtractionEvaluator = {
   examples: []
 };
 
-// src/providers/short-term-memory.ts
-var import_core4 = require("@elizaos/core");
-var shortTermMemoryProvider = {
-  name: "SHORT_TERM_MEMORY",
-  description: "Adaptive conversation context with smart summarization",
-  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 totalMessageCount = await runtime.countMemories(roomId, false, "messages");
-      if (totalMessageCount < config.shortTermSummarizationThreshold) {
-        const conversationLength = runtime.getConversationLength();
-        const [entitiesData, room, recentMessagesData] = await Promise.all([
-          import_core4.getEntityDetails({ runtime, roomId }),
-          runtime.getRoom(roomId),
-          runtime.getMemories({
-            tableName: "messages",
-            roomId,
-            count: conversationLength,
-            unique: false
-          })
-        ]);
-        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"));
-        const isPostFormat = room?.type ? room.type === import_core4.ChannelType.FEED || room.type === import_core4.ChannelType.THREAD : false;
-        const [formattedRecentMessages, formattedRecentPosts] = await Promise.all([
-          import_core4.formatMessages({
-            messages: dialogueMessages,
-            entities: entitiesData
-          }),
-          import_core4.formatPosts({
-            messages: dialogueMessages,
-            entities: entitiesData,
-            conversationHeader: false
-          })
-        ]);
-        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) : "";
-        }
-        const recentPosts = formattedRecentPosts && formattedRecentPosts.length > 0 ? import_core4.addHeader("# Posts in Thread", formattedRecentPosts) : "";
-        const recentMessages = formattedRecentMessages && formattedRecentMessages.length > 0 ? import_core4.addHeader("# Conversation Messages", formattedRecentMessages) : "";
-        if (!recentPosts && !recentMessages && dialogueMessages.length === 0 && !message.content.text) {
-          return {
-            data: {
-              summaries: [],
-              recentMessages: [],
-              actionResults: [],
-              mode: "full_conversation"
-            },
-            values: {
-              recentMessage: "No recent message available."
-            },
-            text: "No recent messages available"
-          };
-        }
-        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 metaData = message.metadata;
-        const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
-        const receivedMessageContent = message.content.text;
-        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 text4 = [
-          isPostFormat ? recentPosts : recentMessages,
-          actionResultsText,
-          recentMessages || recentPosts || message.content.text ? receivedMessageHeader : "",
-          recentMessages || recentPosts || message.content.text ? focusHeader : ""
-        ].filter(Boolean).join(`
-
-`);
-        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 }
-          },
-          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 isPostFormat = room?.type ? room.type === import_core4.ChannelType.FEED || room.type === import_core4.ChannelType.THREAD : false;
-        let recentMessagesText = "";
-        if (unsummarizedMessages.length > 0) {
-          const dialogueMessages = unsummarizedMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result"));
-          if (isPostFormat) {
-            recentMessagesText = import_core4.formatPosts({
-              messages: dialogueMessages,
-              entities: entitiesData,
-              conversationHeader: false
-            });
-          } else {
-            recentMessagesText = import_core4.formatMessages({
-              messages: dialogueMessages,
-              entities: entitiesData
-            });
-          }
-          if (recentMessagesText) {
-            recentMessagesText = import_core4.addHeader("# Recent Messages", recentMessagesText);
-          }
-        }
-        let summaryText = "";
-        if (currentSummary) {
-          const messageRange = `${currentSummary.messageCount} messages`;
-          const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
-          summaryText = `**Previous Conversation** (${messageRange}, ${timeRange})
-`;
-          summaryText += currentSummary.summary;
-          if (currentSummary.topics && currentSummary.topics.length > 0) {
-            summaryText += `
-*Topics: ${currentSummary.topics.join(", ")}*`;
-          }
-          summaryText = import_core4.addHeader("# Conversation Summary", summaryText);
-        }
-        const metaData = message.metadata;
-        const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
-        const receivedMessageContent = message.content.text;
-        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 text4 = [
-          summaryText,
-          recentMessagesText,
-          hasReceivedMessage ? receivedMessageHeader : "",
-          hasReceivedMessage ? focusHeader : ""
-        ].filter(Boolean).join(`
-
-`);
-        return {
-          data: {
-            summaries: currentSummary ? [currentSummary] : [],
-            recentMessages: unsummarizedMessages,
-            mode: "summarized"
-          },
-          values: {
-            ...summaryText && { sessionSummaries: summaryText },
-            ...recentMessagesText && { recentMessages: recentMessagesText },
-            ...receivedMessageHeader && { receivedMessageHeader },
-            ...focusHeader && { focusHeader }
-          },
-          text: text4
-        };
-      }
-    } catch (error) {
-      import_core4.logger.error({ error }, "Error in shortTermMemoryProvider:");
-      return {
-        data: { summaries: [], recentMessages: [], mode: "error" },
-        values: {},
-        text: "Error retrieving conversation context."
-      };
-    }
-  }
-};
-
 // src/providers/long-term-memory.ts
-var import_core5 = require("@elizaos/core");
+var import_core4 = require("@elizaos/core");
 var longTermMemoryProvider = {
   name: "LONG_TERM_MEMORY",
   description: "Persistent facts and preferences about the user",
@@ -1229,7 +1076,7 @@ var longTermMemoryProvider = {
         };
       }
       const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
-      const text4 = import_core5.addHeader("# What I Know About You", formattedMemories);
+      const text4 = import_core4.addHeader("# What I Know About You", formattedMemories);
       const categoryCounts = new Map;
       for (const memory of memories) {
         const count = categoryCounts.get(memory.category) || 0;
@@ -1248,7 +1095,7 @@ var longTermMemoryProvider = {
         text: text4
       };
     } catch (error) {
-      import_core5.logger.error({ error }, "Error in longTermMemoryProvider:");
+      import_core4.logger.error({ error }, "Error in longTermMemoryProvider:");
       return {
         data: { memories: [] },
         values: { longTermMemories: "" },
@@ -1258,15 +1105,215 @@ var longTermMemoryProvider = {
   }
 };
 
+// src/providers/context-summary.ts
+var import_core5 = require("@elizaos/core");
+var contextSummaryProvider = {
+  name: "SUMMARIZED_CONTEXT",
+  description: "Provides summarized context from previous conversations",
+  position: 96,
+  get: async (runtime, message, _state) => {
+    try {
+      const memoryService = runtime.getService("memory");
+      const { roomId } = message;
+      if (!memoryService) {
+        return {
+          data: {
+            summary: null
+          },
+          values: {
+            sessionSummaries: "",
+            sessionSummariesWithTopics: ""
+          },
+          text: ""
+        };
+      }
+      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
+      if (!currentSummary) {
+        return {
+          data: {
+            summary: null
+          },
+          values: {
+            sessionSummaries: "",
+            sessionSummariesWithTopics: ""
+          },
+          text: ""
+        };
+      }
+      const messageRange = `${currentSummary.messageCount} messages`;
+      const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
+      let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})
+`;
+      summaryOnly += currentSummary.summary;
+      let summaryWithTopics = summaryOnly;
+      if (currentSummary.topics && currentSummary.topics.length > 0) {
+        summaryWithTopics += `
+*Topics: ${currentSummary.topics.join(", ")}*`;
+      }
+      const sessionSummaries2 = import_core5.addHeader("# Conversation Summary", summaryOnly);
+      const sessionSummariesWithTopics = import_core5.addHeader("# Conversation Summary", summaryWithTopics);
+      return {
+        data: {
+          summary: currentSummary
+        },
+        values: {
+          sessionSummaries: sessionSummaries2,
+          sessionSummariesWithTopics
+        },
+        text: sessionSummariesWithTopics
+      };
+    } catch (error) {
+      import_core5.logger.error({ error }, "Error in contextSummaryProvider:");
+      return {
+        data: {
+          summary: null
+        },
+        values: {
+          sessionSummaries: "",
+          sessionSummariesWithTopics: ""
+        },
+        text: ""
+      };
+    }
+  }
+};
+
+// src/providers/recent-messages.ts
+var import_core6 = require("@elizaos/core");
+var recentMessagesProvider = {
+  name: "RECENT_MESSAGES",
+  description: "Provides recent conversation messages with detailed context",
+  position: 94,
+  get: async (runtime, message, _state) => {
+    try {
+      const memoryService = runtime.getService("memory");
+      const { roomId } = message;
+      const config = memoryService?.getConfig() || {
+        shortTermSummarizationThreshold: 16,
+        shortTermRetainRecent: 6
+      };
+      const conversationLength = runtime.getConversationLength();
+      let messagesToFetch = config.shortTermRetainRecent;
+      let startOffset = 0;
+      let hasSummary = false;
+      if (memoryService) {
+        const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
+        if (currentSummary) {
+          hasSummary = true;
+          startOffset = currentSummary.lastMessageOffset || 0;
+        }
+      }
+      if (!hasSummary) {
+        const allMessages = await runtime.getMemories({
+          tableName: "messages",
+          roomId,
+          count: conversationLength,
+          unique: false
+        });
+        const dialogueMessageCount = allMessages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message")).length;
+        if (dialogueMessageCount < config.shortTermSummarizationThreshold) {
+          messagesToFetch = conversationLength;
+        }
+      }
+      const [entitiesData, room, recentMessagesData] = await Promise.all([
+        import_core6.getEntityDetails({ runtime, roomId }),
+        runtime.getRoom(roomId),
+        runtime.getMemories({
+          tableName: "messages",
+          roomId,
+          count: messagesToFetch,
+          unique: false,
+          start: startOffset
+        })
+      ]);
+      const isPostFormat = room?.type ? room.type === import_core6.ChannelType.FEED || room.type === import_core6.ChannelType.THREAD : false;
+      const dialogueMessages = recentMessagesData.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
+      let recentMessagesText = "";
+      if (dialogueMessages.length > 0) {
+        if (isPostFormat) {
+          recentMessagesText = import_core6.formatPosts({
+            messages: dialogueMessages,
+            entities: entitiesData,
+            conversationHeader: false
+          });
+        } else {
+          recentMessagesText = import_core6.formatMessages({
+            messages: dialogueMessages,
+            entities: entitiesData
+          });
+        }
+        if (recentMessagesText) {
+          recentMessagesText = import_core6.addHeader("# Recent Messages", recentMessagesText);
+        }
+      }
+      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 = import_core6.addHeader("# Conversation Messages", formatConversationLog(dialogueMessages, false));
+      const conversationLogWithAgentThoughts = import_core6.addHeader("# Conversation Messages", formatConversationLog(dialogueMessages, true));
+      const metaData = message.metadata;
+      const senderName = entitiesData.find((entity) => entity.id === message.entityId)?.names[0] || metaData?.entityName || "Unknown User";
+      const receivedMessageContent = message.content.text;
+      const hasReceivedMessage = !!receivedMessageContent?.trim();
+      const receivedMessageHeader = hasReceivedMessage ? import_core6.addHeader("# Received Message", `${senderName}: ${receivedMessageContent}`) : "";
+      const focusHeader = hasReceivedMessage ? import_core6.addHeader("# Focus your response", `You are replying to the above message from **${senderName}**. Keep your answer relevant to that message.`) : "";
+      const text4 = [recentMessagesText, receivedMessageHeader, focusHeader].filter(Boolean).join(`
+
+`);
+      return {
+        data: {
+          messages: dialogueMessages
+        },
+        values: {
+          recentMessages: recentMessagesText,
+          conversationLog,
+          conversationLogWithAgentThoughts,
+          ...receivedMessageHeader && { receivedMessageHeader },
+          ...focusHeader && { focusHeader }
+        },
+        text: text4
+      };
+    } catch (error) {
+      import_core6.logger.error({ error }, "Error in recentMessagesProvider:");
+      return {
+        data: {
+          messages: []
+        },
+        values: {
+          recentMessages: "",
+          conversationLog: "",
+          conversationLogWithAgentThoughts: "",
+          receivedMessageHeader: "",
+          focusHeader: ""
+        },
+        text: ""
+      };
+    }
+  }
+};
+
 // src/index.ts
 var memoryPlugin = {
   name: "memory",
   description: "Advanced memory management with conversation summarization and long-term persistent memory",
   services: [MemoryService],
   evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
-  providers: [longTermMemoryProvider, shortTermMemoryProvider],
+  providers: [
+    longTermMemoryProvider,
+    contextSummaryProvider,
+    recentMessagesProvider
+  ],
   schema: exports_schemas
 };
 var src_default = memoryPlugin;
 
-//# debugId=3C20A9F0BA14039464756E2164756E21
+//# debugId=D8A71511D9B322A664756E2164756E21