@elizaos/plugin-memory 1.0.6 → 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
 });
@@ -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:");
@@ -1024,475 +1043,8 @@ var longTermExtractionEvaluator = {
   examples: []
 };
 
-// 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: "Unified conversation context with smart summarization and interactions",
-  position: 95,
-  get: async (runtime, message, _state) => {
-    try {
-      const memoryService = runtime.getService("memory");
-      const { roomId } = message;
-      const conversationLength = 16;
-      const config = memoryService?.getConfig() || {
-        shortTermSummarizationThreshold: 16,
-        shortTermRetainRecent: 6
-      };
-      const totalMessageCount = await runtime.countMemories(roomId, false, "messages");
-      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({
-            tableName: "messages",
-            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"));
-        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
-          })
-        ]);
-        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;
-          for (const mem of actionResultMessages) {
-            const runId = String(mem.content?.runId || "unknown");
-            if (!groupedByRun.has(runId)) {
-              groupedByRun.set(runId, []);
-            }
-            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));
-            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: [],
-              recentInteractions: [],
-              actionResults: [],
-              mode: "full_conversation"
-            },
-            values: {
-              recentPosts: "",
-              recentMessages: "",
-              recentMessageInteractions: "",
-              recentPostInteractions: "",
-              recentInteractions: "",
-              recentActionResults: "",
-              recentMessage: "No recent message available.",
-              conversationLog: "",
-              conversationLogWithAgentThoughts: ""
-            },
-            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 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,
-          recentMessages || recentPosts || message.content.text ? receivedMessageHeader : "",
-          recentMessages || recentPosts || message.content.text ? focusHeader : ""
-        ].filter(Boolean).join(`
-
-`);
-        return {
-          data,
-          values,
-          text: text4
-        };
-      } else {
-        const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
-        const lastOffset = currentSummary?.lastMessageOffset || 0;
-        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 (dialogueMessages.length > 0) {
-          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 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`;
-          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 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(`
-
-`);
-        return {
-          data: {
-            summaries: currentSummary ? [currentSummary] : [],
-            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 }
-          },
-          text: text4
-        };
-      }
-    } catch (error) {
-      import_core4.logger.error({ error }, "Error in shortTermMemoryProvider:");
-      return {
-        data: {
-          summaries: [],
-          recentMessages: [],
-          recentInteractions: [],
-          actionResults: [],
-          mode: "error"
-        },
-        values: {
-          recentPosts: "",
-          recentMessages: "",
-          recentMessageInteractions: "",
-          recentPostInteractions: "",
-          recentInteractions: "",
-          recentActionResults: "",
-          conversationLog: "",
-          conversationLogWithAgentThoughts: ""
-        },
-        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",
@@ -1524,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;
@@ -1543,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: "" },
@@ -1553,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=A3C66779A69339CA64756E2164756E21
+//# debugId=D8A71511D9B322A664756E2164756E21