@elizaos/plugin-memory 2.0.0-alpha.3 → 2.0.0-alpha.5

package/dist/index.js

@@ -1,1133 +1,499 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: (newValue) => all[name] = () => newValue
-    });
-};
-
-// src/evaluators/long-term-extraction.ts
+// src/actions/forget.ts
 import {
-  composePromptFromState,
   logger,
   ModelType
 } from "@elizaos/core";
 
-// src/generated/prompts/typescript/prompts.ts
-var initialSummarizationTemplate = `# Task: Summarize Conversation
-
-You are analyzing a conversation to create a concise summary that captures the key points, topics, and important details.
-
-# Recent Messages
-{{recentMessages}}
-
-# Instructions
-Generate a summary that:
-1. Captures the main topics discussed
-2. Highlights key information shared
-3. Notes any decisions made or questions asked
-4. Maintains context for future reference
-5. Is concise but comprehensive
-
-**IMPORTANT**: Keep the summary under 2500 tokens. Be comprehensive but concise.
-
-Also extract:
-- **Topics**: List of main topics discussed (comma-separated)
-- **Key Points**: Important facts or decisions (bullet points)
-
-Respond in this XML format:
-<summary>
-  <text>Your comprehensive summary here</text>
-  <topics>topic1, topic2, topic3</topics>
-  <keyPoints>
-    <point>First key point</point>
-    <point>Second key point</point>
-  </keyPoints>
-</summary>`;
-var longTermExtractionTemplate = `# Task: Extract Long-Term Memory (Strict Criteria)
-
-You are analyzing a conversation to extract ONLY the most critical, persistent information about the user using cognitive science memory categories.
-
-# Recent Messages
-{{recentMessages}}
-
-# Current Long-Term Memories
-{{existingMemories}}
-
-# Memory Categories (Based on Cognitive Science)
-
-## 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"
-
-**Requirements:**
-- Must include WHO did WHAT, WHEN/WHERE
-- Must be a specific, concrete event (not a pattern)
-- Must have significant impact or relevance to future work
-
-## 2. SEMANTIC Memory
-General facts, concepts, knowledge, and established truths about the user.
-**Examples:**
-- "User is a senior backend engineer with 8 years experience"
-- "User specializes in distributed systems and microservices architecture"
-- "User's primary programming language is TypeScript"
-- "User works at Acme Corp as technical lead"
-
-**Requirements:**
-- Must be factual, timeless information
-- Must be explicitly stated or demonstrated conclusively
-- No speculation or inference from single instances
-- Core identity, expertise, or knowledge only
-
-## 3. PROCEDURAL Memory
-Skills, workflows, methodologies, and how-to knowledge.
-**Examples:**
-- "User follows strict TDD workflow: write tests first, then implementation"
-- "User prefers git rebase over merge to maintain linear history"
-- "User's debugging process: check logs → reproduce locally → binary search"
-- "User always writes JSDoc comments before implementing functions"
-
-**Requirements:**
-- Must describe HOW user does something
-- Must be a repeated, consistent pattern (seen 3+ times or explicitly stated as standard practice)
-- Must be a workflow, methodology, or skill application
-- Not one-off preferences
-
-# ULTRA-STRICT EXTRACTION CRITERIA
-
-## ✅ DO EXTRACT (Only These):
-
-**EPISODIC:**
-- Significant completed projects or milestones
-- Important bugs, incidents, or problems encountered
-- Major decisions made with lasting impact
-- Formative experiences that shape future work
-
-**SEMANTIC:**
-- Professional identity (role, title, company)
-- Core expertise and specializations (stated explicitly or demonstrated conclusively)
-- Primary languages, frameworks, or tools (not exploratory use)
-- Established facts about their work context
-
-**PROCEDURAL:**
-- Consistent workflows demonstrated 3+ times or explicitly stated
-- Standard practices user always follows
-- Methodology preferences with clear rationale
-- Debugging, testing, or development processes
-
-## ❌ NEVER EXTRACT:
-
-- **One-time requests or tasks** (e.g., "can you generate an image", "help me debug this")
-- **Casual conversations** without lasting significance
-- **Exploratory questions** (e.g., "how does X work?")
-- **Temporary context** (current bug, today's task)
-- **Preferences from single occurrence** (e.g., user asked for code once)
-- **Social pleasantries** (thank you, greetings)
-- **Testing or experimentation** (trying out a feature)
-- **Common patterns everyone has** (likes clear explanations)
-- **Situational information** (working on feature X today)
-- **Opinions without persistence** (single complaint, isolated praise)
-- **General knowledge** (not specific to user)
-
-# Quality Gates (ALL Must Pass)
-
-1. **Significance Test**: Will this matter in 3+ months?
-2. **Specificity Test**: Is this concrete and actionable?
-3. **Evidence Test**: Is there strong evidence (3+ instances OR explicit self-identification)?
-4. **Uniqueness Test**: Is this specific to THIS user (not generic)?
-5. **Confidence Test**: Confidence must be >= 0.85 (be VERY conservative)
-6. **Non-Redundancy Test**: Does this add NEW information not in existing memories?
-
-# Confidence Scoring (Be Conservative)
-
-- **0.95-1.0**: User explicitly stated as core identity/practice AND demonstrated multiple times
-- **0.85-0.94**: User explicitly stated OR consistently demonstrated 5+ times
-- **0.75-0.84**: Strong pattern (3-4 instances) with supporting context
-- **Below 0.75**: DO NOT EXTRACT (insufficient evidence)
-
-# Critical Instructions
-
-1. **Default to NOT extracting** - When in doubt, skip it
-2. **Require overwhelming evidence** - One or two mentions is NOT enough
-3. **Focus on what's PERSISTENT** - Not what's temporary or situational
-4. **Verify against existing memories** - Don't duplicate or contradict
-5. **Maximum 2-3 extractions per run** - Quality over quantity
-
-**If there are no qualifying facts (which is common), respond with <memories></memories>**
-
-# Response Format
-
-<memories>
-  <memory>
-    <category>semantic</category>
-    <content>User is a senior TypeScript developer with 8 years of backend experience</content>
-    <confidence>0.95</confidence>
-  </memory>
-  <memory>
-    <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>`;
-var updateSummarizationTemplate = `# Task: Update and Condense Conversation Summary
-
-You are updating an existing conversation summary with new messages, while keeping the total summary concise.
-
-# Existing Summary
-{{existingSummary}}
-
-# Existing Topics
-{{existingTopics}}
-
-# New Messages Since Last Summary
-{{newMessages}}
-
-# Instructions
-Update the summary by:
-1. Merging the existing summary with insights from the new messages
-2. Removing redundant or less important details to stay under the token limit
-3. Keeping the most important context and decisions
-4. Adding new topics if they emerge
-5. **CRITICAL**: Keep the ENTIRE updated summary under 2500 tokens
-
-The goal is a rolling summary that captures the essence of the conversation without growing indefinitely.
-
-Respond in this XML format:
-<summary>
-  <text>Your updated and condensed summary here</text>
-  <topics>topic1, topic2, topic3</topics>
-  <keyPoints>
-    <point>First key point</point>
-    <point>Second key point</point>
-  </keyPoints>
-</summary>`;
-
-// src/types/index.ts
-var LongTermMemoryCategory;
-((LongTermMemoryCategory2) => {
-  LongTermMemoryCategory2["EPISODIC"] = "episodic";
-  LongTermMemoryCategory2["SEMANTIC"] = "semantic";
-  LongTermMemoryCategory2["PROCEDURAL"] = "procedural";
-})(LongTermMemoryCategory ||= {});
-
-// src/evaluators/long-term-extraction.ts
-var extractionTemplate = longTermExtractionTemplate;
-function parseMemoryExtractionXML(xml) {
-  const memoryMatches = xml.matchAll(/<memory>[\s\S]*?<category>(.*?)<\/category>[\s\S]*?<content>(.*?)<\/content>[\s\S]*?<confidence>(.*?)<\/confidence>[\s\S]*?<\/memory>/g);
-  const extractions = [];
-  for (const match of memoryMatches) {
-    const category = match[1].trim();
-    const content = match[2].trim();
-    const confidence = parseFloat(match[3].trim());
-    if (!Object.values(LongTermMemoryCategory).includes(category)) {
-      logger.warn(`Invalid memory category: ${category}`);
-      continue;
-    }
-    if (content && !Number.isNaN(confidence)) {
-      extractions.push({ category, content, confidence });
-    }
+// src/types.ts
+var MemoryImportance;
+((MemoryImportance2) => {
+  MemoryImportance2[MemoryImportance2["LOW"] = 1] = "LOW";
+  MemoryImportance2[MemoryImportance2["NORMAL"] = 2] = "NORMAL";
+  MemoryImportance2[MemoryImportance2["HIGH"] = 3] = "HIGH";
+  MemoryImportance2[MemoryImportance2["CRITICAL"] = 4] = "CRITICAL";
+})(MemoryImportance ||= {});
+var MEMORY_METADATA_SEPARATOR = `
+---
+`;
+var MEMORY_SOURCE = "plugin-memory";
+var IMPORTANCE_LABELS = {
+  [1 /* LOW */]: "low",
+  [2 /* NORMAL */]: "normal",
+  [3 /* HIGH */]: "high",
+  [4 /* CRITICAL */]: "critical"
+};
+function encodeMemoryText(content, tags, importance) {
+  const metadata = JSON.stringify({ t: tags, i: importance });
+  return `${metadata}${MEMORY_METADATA_SEPARATOR}${content}`;
+}
+function decodeMemoryText(text) {
+  const separatorIndex = text.indexOf(MEMORY_METADATA_SEPARATOR);
+  if (separatorIndex === -1) {
+    return { content: text, tags: [], importance: 2 /* NORMAL */ };
+  }
+  const metadataStr = text.substring(0, separatorIndex);
+  const content = text.substring(separatorIndex + MEMORY_METADATA_SEPARATOR.length);
+  try {
+    const metadata = JSON.parse(metadataStr);
+    return {
+      content,
+      tags: Array.isArray(metadata.t) ? metadata.t.map(String) : [],
+      importance: typeof metadata.i === "number" ? metadata.i : 2 /* NORMAL */
+    };
+  } catch {
+    return { content: text, tags: [], importance: 2 /* NORMAL */ };
   }
-  return extractions;
 }
-var longTermExtractionEvaluator = {
-  name: "LONG_TERM_MEMORY_EXTRACTION",
-  description: "Extracts long-term facts about users from conversations",
-  similes: ["MEMORY_EXTRACTION", "FACT_LEARNING", "USER_PROFILING"],
-  alwaysRun: true,
-  validate: async (runtime, message) => {
-    if (message.entityId === runtime.agentId) {
-      return false;
-    }
-    if (!message.content?.text) {
-      return false;
-    }
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      return false;
-    }
-    const config = memoryService.getConfig();
-    if (!config.longTermExtractionEnabled) {
-      logger.debug("Long-term memory extraction is disabled");
-      return false;
-    }
-    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
-    return memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
-  },
-  handler: async (runtime, message) => {
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger.error("MemoryService not found");
-      return;
-    }
-    const config = memoryService.getConfig();
-    const { entityId, roomId } = message;
-    try {
-      logger.info(`Extracting long-term memories for entity ${entityId}`);
-      const recentMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: 20,
-        unique: false
-      });
-      const formattedMessages = recentMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0)).map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
-`);
-      const existingMemories = await memoryService.getLongTermMemories(entityId, undefined, 30);
-      const formattedExisting = existingMemories.length > 0 ? existingMemories.map((m) => `[${m.category}] ${m.content} (confidence: ${m.confidence})`).join(`
-`) : "None yet";
-      const state = await runtime.composeState(message);
-      const prompt = composePromptFromState({
-        state: {
-          ...state,
-          recentMessages: formattedMessages,
-          existingMemories: formattedExisting
-        },
-        template: extractionTemplate
-      });
-      const response = await runtime.useModel(ModelType.TEXT_LARGE, { prompt });
-      const extractions = parseMemoryExtractionXML(response);
-      logger.info(`Extracted ${extractions.length} long-term memories`);
-      for (const extraction of extractions) {
-        if (extraction.confidence >= Math.max(config.longTermConfidenceThreshold, 0.85)) {
-          await memoryService.storeLongTermMemory({
-            agentId: runtime.agentId,
-            entityId,
-            category: extraction.category,
-            content: extraction.content,
-            confidence: extraction.confidence,
-            source: "conversation",
-            metadata: {
-              roomId,
-              extractedAt: new Date().toISOString()
-            }
-          });
-          logger.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
-        } else {
-          logger.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
+
+// src/actions/forget.ts
+var forgetAction = {
+  name: "FORGET",
+  description: "Remove a stored memory by ID or by matching content description",
+  similes: ["forget", "remove-memory", "delete-memory", "erase-memory", "clear-memory"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: { text: "Forget what you know about my favorite color." }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll remove that memory about your favorite color.",
+          actions: ["FORGET"]
         }
       }
-      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
-      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
-      logger.debug(`Updated checkpoint to ${currentMessageCount} for entity ${entityId}`);
-    } catch (error) {
-      logger.error({ error }, "Error during long-term memory extraction:");
-    }
-    return;
-  },
-  examples: []
-};
-// src/evaluators/summarization.ts
-import {
-  composePromptFromState as composePromptFromState2,
-  logger as logger2,
-  ModelType as ModelType2
-} from "@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;
-}
-function parseSummaryXML(xml) {
-  const summaryMatch = xml.match(/<text>([\s\S]*?)<\/text>/);
-  const topicsMatch = xml.match(/<topics>([\s\S]*?)<\/topics>/);
-  const keyPointsMatches = xml.matchAll(/<point>([\s\S]*?)<\/point>/g);
-  const summary = summaryMatch ? summaryMatch[1].trim() : "Summary not available";
-  const topics = topicsMatch ? topicsMatch[1].split(",").map((t) => t.trim()).filter(Boolean) : [];
-  const keyPoints = Array.from(keyPointsMatches).map((match) => match[1].trim());
-  return { summary, topics, keyPoints };
-}
-var summarizationEvaluator = {
-  name: "MEMORY_SUMMARIZATION",
-  description: "Automatically summarizes conversations to optimize context usage",
-  similes: ["CONVERSATION_SUMMARY", "CONTEXT_COMPRESSION", "MEMORY_OPTIMIZATION"],
-  alwaysRun: true,
-  validate: async (runtime, message) => {
-    if (!message.content?.text) {
-      return false;
-    }
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      return false;
-    }
-    const config = memoryService.getConfig();
-    const currentDialogueCount = await getDialogueMessageCount(runtime, message.roomId);
-    const existingSummary = await memoryService.getCurrentSessionSummary(message.roomId);
-    if (!existingSummary) {
-      return currentDialogueCount >= config.shortTermSummarizationThreshold;
-    } else {
-      const newDialogueCount = currentDialogueCount - existingSummary.lastMessageOffset;
-      return newDialogueCount >= config.shortTermSummarizationInterval;
-    }
+    ],
+    [
+      {
+        name: "User",
+        content: { text: "Delete the memory about the project deadline." }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I've removed the memory about the project deadline.",
+          actions: ["FORGET"]
+        }
+      }
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const memoryManager = runtime.getMemoryManager();
+    return !!memoryManager;
   },
-  handler: async (runtime, message) => {
-    const memoryService = runtime.getService("memory");
-    if (!memoryService) {
-      logger2.error("MemoryService not found");
-      return;
-    }
-    const config = memoryService.getConfig();
-    const { roomId } = message;
+  async handler(runtime, message, _state, _options, callback) {
     try {
-      logger2.info(`Starting summarization for room ${roomId}`);
-      const existingSummary = await memoryService.getCurrentSessionSummary(roomId);
-      const lastOffset = existingSummary?.lastMessageOffset || 0;
-      const allMessages = await runtime.getMemories({
-        tableName: "messages",
-        roomId,
-        count: 1000,
-        unique: false
-      });
-      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) {
-        logger2.debug("No new dialogue messages to summarize");
-        return;
+      const memoryManager = runtime.getMemoryManager();
+      if (!memoryManager) {
+        throw new Error("Memory manager not available");
       }
-      const maxNewMessages = config.summaryMaxNewMessages || 50;
-      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
-      if (newDialogueCount > maxNewMessages) {
-        logger2.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available)`);
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please specify which memory to forget.";
+        await callback?.({ text: errorMessage, source: message.content.source });
+        return { text: errorMessage, success: false };
       }
-      const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
-      if (newDialogueMessages.length === 0) {
-        logger2.debug("No new dialogue messages retrieved after filtering");
-        return;
+      const params = _options?.parameters;
+      if (params?.memoryId) {
+        await memoryManager.removeMemory(params.memoryId);
+        const successMessage2 = `Removed memory with ID: ${params.memoryId}`;
+        await callback?.({ text: successMessage2, source: message.content.source });
+        return { text: successMessage2, success: true, data: { removedId: params.memoryId } };
       }
-      const formattedMessages = newDialogueMessages.map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
-`);
-      const state = await runtime.composeState(message);
-      let prompt;
-      let template;
-      if (existingSummary) {
-        template = updateSummarizationTemplate;
-        prompt = composePromptFromState2({
-          state: {
-            ...state,
-            existingSummary: existingSummary.summary,
-            existingTopics: existingSummary.topics?.join(", ") || "None",
-            newMessages: formattedMessages
-          },
-          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 = composePromptFromState2({
-          state: { ...state, recentMessages: initialMessages },
-          template
-        });
+      const memories = await memoryManager.getMemories({
+        roomId: message.roomId,
+        count: 100
+      });
+      const pluginMemories = memories.filter((m) => m.content.source === MEMORY_SOURCE);
+      if (pluginMemories.length === 0) {
+        const noMemoriesMsg = "No stored memories found to remove.";
+        await callback?.({ text: noMemoriesMsg, source: message.content.source });
+        return { text: noMemoriesMsg, success: true };
       }
-      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
-        prompt,
-        maxTokens: config.summaryMaxTokens || 2500
+      const searchContent = params?.content ?? content;
+      const memoryDescriptions = pluginMemories.map((m, i) => {
+        const parsed2 = decodeMemoryText(m.content.text);
+        return `${i}: "${parsed2.content}"`;
       });
-      const summaryResult = parseSummaryXML(response);
-      logger2.info(`${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
-      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 + newDialogueMessages.length,
-          lastMessageOffset: newOffset,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: { keyPoints: summaryResult.keyPoints }
-        });
-        logger2.info(`Updated summary for room ${roomId}: ${newDialogueMessages.length} messages processed`);
-      } else {
-        await memoryService.storeSessionSummary({
-          agentId: runtime.agentId,
-          roomId,
-          entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
-          summary: summaryResult.summary,
-          messageCount: totalDialogueCount,
-          lastMessageOffset: totalDialogueCount,
-          startTime,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: { keyPoints: summaryResult.keyPoints }
-        });
-        logger2.info(`Created summary for room ${roomId}: ${totalDialogueCount} messages summarized`);
+      const matchPrompt = `Given the user's request to forget a memory, identify which stored memory index matches best.
+
+User request: "${searchContent}"
+
+Available memories:
+${memoryDescriptions.join(`
+`)}
+
+Return ONLY a JSON object (no markdown, no code blocks):
+{"index": <number or -1 if no match>, "confidence": <0.0 to 1.0>}`;
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt: matchPrompt
+      });
+      if (!response) {
+        throw new Error("Failed to identify memory to remove");
+      }
+      const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+      const match = JSON.parse(cleaned);
+      if (match.index < 0 || match.index >= pluginMemories.length || match.confidence < 0.5) {
+        const noMatchMsg = "Could not find a matching memory to remove. Please be more specific.";
+        await callback?.({ text: noMatchMsg, source: message.content.source });
+        return { text: noMatchMsg, success: false };
       }
+      const targetMemory = pluginMemories[match.index];
+      const parsed = decodeMemoryText(targetMemory.content.text);
+      const memoryId = targetMemory.id ?? "";
+      if (memoryId) {
+        await memoryManager.removeMemory(memoryId);
+      }
+      const successMessage = `Removed memory: "${parsed.content}"`;
+      await callback?.({ text: successMessage, source: message.content.source });
+      return {
+        text: successMessage,
+        success: true,
+        data: { removedId: memoryId, content: parsed.content }
+      };
     } catch (error) {
-      logger2.error({ error }, "Error during summarization:");
+      logger.error("Failed to forget memory:", error);
+      const errorMessage = `Failed to forget memory: ${error instanceof Error ? error.message : String(error)}`;
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
     }
-    return;
-  },
-  examples: []
+  }
 };
-// src/providers/context-summary.ts
+
+// src/actions/recall.ts
 import {
-  addHeader,
-  logger as logger3
+  logger as logger2
 } from "@elizaos/core";
-var contextSummaryProvider = {
-  name: "SUMMARIZED_CONTEXT",
-  description: "Provides summarized context from previous conversations",
-  position: 96,
-  get: async (runtime, message, _state) => {
+var recallAction = {
+  name: "RECALL",
+  description: "Retrieve stored memories based on a query, tags, or topic",
+  similes: ["recall", "remember-what", "search-memory", "find-memory", "what-do-you-remember"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: { text: "What do you remember about my preferences?" }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Let me search my memories about your preferences.",
+          actions: ["RECALL"]
+        }
+      }
+    ],
+    [
+      {
+        name: "User",
+        content: { text: "Recall everything about the project deadline." }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll look up what I know about the project deadline.",
+          actions: ["RECALL"]
+        }
+      }
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const memoryManager = runtime.getMemoryManager();
+    return !!memoryManager;
+  },
+  async handler(runtime, message, _state, _options, callback) {
     try {
-      const memoryService = runtime.getService("memory");
-      const { roomId } = message;
-      if (!memoryService) {
-        return {
-          data: {},
-          values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
-          text: ""
-        };
+      const memoryManager = runtime.getMemoryManager();
+      if (!memoryManager) {
+        throw new Error("Memory manager not available");
+      }
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please provide a query to recall memories.";
+        await callback?.({ text: errorMessage, source: message.content.source });
+        return { text: errorMessage, success: false };
       }
-      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
-      if (!currentSummary) {
+      const params = _options?.parameters;
+      const query = params?.query ?? content;
+      const filterTags = params?.tags ?? [];
+      const limit = params?.limit ?? 10;
+      const minImportance = params?.minImportance ?? 1 /* LOW */;
+      const memories = await memoryManager.getMemories({
+        roomId: message.roomId,
+        count: 100
+      });
+      const pluginMemories = memories.filter((m) => m.content.source === MEMORY_SOURCE);
+      if (pluginMemories.length === 0) {
+        const noMemoriesMsg = "I don't have any stored memories yet.";
+        await callback?.({ text: noMemoriesMsg, source: message.content.source });
+        return { text: noMemoriesMsg, success: true, data: { memories: [], count: 0 } };
+      }
+      const parsedMemories = pluginMemories.map((m) => {
+        const parsed = decodeMemoryText(m.content.text);
         return {
-          data: {},
-          values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
-          text: ""
+          id: m.id ?? "",
+          content: parsed.content,
+          tags: parsed.tags,
+          importance: parsed.importance,
+          createdAt: m.createdAt ?? 0
         };
+      }).filter((m) => m.importance >= minImportance);
+      let filteredMemories = parsedMemories;
+      if (filterTags.length > 0) {
+        filteredMemories = parsedMemories.filter((m) => filterTags.some((tag) => m.tags.includes(tag)));
       }
-      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 queryLower = query.toLowerCase();
+      const queryWords = queryLower.split(/\s+/);
+      const scoredMemories = filteredMemories.map((m) => {
+        const contentLower = m.content.toLowerCase();
+        const tagsStr = m.tags.join(" ").toLowerCase();
+        let score = 0;
+        if (contentLower.includes(queryLower)) {
+          score += 10;
+        }
+        for (const word of queryWords) {
+          if (word.length < 2)
+            continue;
+          if (contentLower.includes(word))
+            score += 2;
+          if (tagsStr.includes(word))
+            score += 3;
+        }
+        score += m.importance;
+        return { ...m, score };
+      }).filter((m) => m.score > 0).sort((a, b) => b.score - a.score).slice(0, limit);
+      if (scoredMemories.length === 0) {
+        const noResultsMsg = "No memories found matching your query.";
+        await callback?.({ text: noResultsMsg, source: message.content.source });
+        return { text: noResultsMsg, success: true, data: { memories: [], count: 0 } };
       }
-      const sessionSummaries = addHeader("# Conversation Summary", summaryOnly);
-      const sessionSummariesWithTopics = addHeader("# Conversation Summary", summaryWithTopics);
+      const memoryList = scoredMemories.map((m, i) => {
+        const tagStr = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+        const date = new Date(m.createdAt).toLocaleDateString();
+        return `${i + 1}. ${m.content}${tagStr} (${date})`;
+      }).join(`
+`);
+      const count = scoredMemories.length;
+      const resultText = `Found ${count} memor${count === 1 ? "y" : "ies"}:
+
+${memoryList}`;
+      await callback?.({ text: resultText, source: message.content.source });
       return {
+        text: resultText,
+        success: true,
         data: {
-          summaryText: currentSummary.summary,
-          messageCount: currentSummary.messageCount,
-          topics: currentSummary.topics?.join(", ") || ""
-        },
-        values: { sessionSummaries, sessionSummariesWithTopics },
-        text: sessionSummariesWithTopics
+          memories: scoredMemories.map((m) => ({
+            id: m.id,
+            content: m.content,
+            tags: m.tags,
+            importance: m.importance,
+            createdAt: m.createdAt
+          })),
+          count
+        }
       };
     } catch (error) {
-      logger3.error({ error }, "Error in contextSummaryProvider:");
-      return {
-        data: {},
-        values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
-        text: ""
-      };
+      logger2.error("Failed to recall memories:", error);
+      const errorMessage = `Failed to recall memories: ${error instanceof Error ? error.message : String(error)}`;
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
     }
   }
 };
-// src/providers/long-term-memory.ts
+
+// src/actions/remember.ts
 import {
-  addHeader as addHeader2,
-  logger as logger4
+  logger as logger3,
+  ModelType as ModelType2
 } from "@elizaos/core";
-var longTermMemoryProvider = {
-  name: "LONG_TERM_MEMORY",
-  description: "Persistent facts and preferences about the user",
-  position: 50,
-  get: async (runtime, message, _state) => {
-    try {
-      const memoryService = runtime.getService("memory");
-      if (!memoryService) {
-        return {
-          data: { memoryCount: 0 },
-          values: { longTermMemories: "" },
-          text: ""
-        };
+var rememberAction = {
+  name: "REMEMBER",
+  description: "Store a piece of information as a long-term memory for later recall",
+  similes: ["remember", "memorize", "store-memory", "save-memory", "note-down"],
+  examples: [
+    [
+      {
+        name: "User",
+        content: { text: "Remember that my favorite color is blue." }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "I'll remember that your favorite color is blue.",
+          actions: ["REMEMBER"]
+        }
       }
-      const { entityId } = message;
-      if (entityId === runtime.agentId) {
-        return {
-          data: { memoryCount: 0 },
-          values: { longTermMemories: "" },
-          text: ""
-        };
+    ],
+    [
+      {
+        name: "User",
+        content: {
+          text: "Please memorize this: the project deadline is March 15th."
+        }
+      },
+      {
+        name: "Assistant",
+        content: {
+          text: "Got it, I've stored that the project deadline is March 15th.",
+          actions: ["REMEMBER"]
+        }
       }
-      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
-      if (memories.length === 0) {
-        return {
-          data: { memoryCount: 0 },
-          values: { longTermMemories: "" },
-          text: ""
-        };
+    ]
+  ],
+  async validate(runtime, _message, _state) {
+    const memoryManager = runtime.getMemoryManager();
+    return !!memoryManager;
+  },
+  async handler(runtime, message, _state, _options, callback) {
+    try {
+      const memoryManager = runtime.getMemoryManager();
+      if (!memoryManager) {
+        throw new Error("Memory manager not available");
       }
-      const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
-      const text = addHeader2("# What I Know About You", formattedMemories);
-      const categoryCounts = new Map;
-      for (const memory of memories) {
-        const count = categoryCounts.get(memory.category) || 0;
-        categoryCounts.set(memory.category, count + 1);
+      const content = message.content.text;
+      if (!content) {
+        const errorMessage = "Please provide content to remember.";
+        await callback?.({ text: errorMessage, source: message.content.source });
+        return { text: errorMessage, success: false };
       }
-      const categoryList = Array.from(categoryCounts.entries()).map(([cat, count]) => `${cat}: ${count}`).join(", ");
-      return {
-        data: {
-          memoryCount: memories.length,
-          categories: categoryList
-        },
-        values: {
-          longTermMemories: text,
-          memoryCategories: categoryList
+      const params = _options?.parameters;
+      let memoryText = params?.content ?? content;
+      let tags = params?.tags ?? [];
+      let importance = params?.importance ?? 2 /* NORMAL */;
+      if (!params?.content) {
+        const extractionPrompt = `Extract the key information to remember from this message.
+Return ONLY a JSON object (no markdown, no code blocks):
+{
+  "memory": "The concise fact or information to store",
+  "tags": ["relevant", "category", "tags"],
+  "importance": 2
+}
+
+Importance levels: 1=low, 2=normal, 3=high, 4=critical
+
+User message: "${content}"`;
+        const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+          prompt: extractionPrompt
+        });
+        if (response) {
+          try {
+            const cleaned = response.replace(/^```(?:json)?\n?/, "").replace(/\n?```$/, "").trim();
+            const parsed = JSON.parse(cleaned);
+            memoryText = parsed.memory ?? content;
+            tags = Array.isArray(parsed.tags) ? parsed.tags.map(String) : [];
+            importance = typeof parsed.importance === "number" ? parsed.importance : 2 /* NORMAL */;
+          } catch (parseError) {
+            logger3.warn("Failed to parse memory extraction, using raw content", parseError);
+            memoryText = content;
+          }
+        }
+      }
+      const encodedText = encodeMemoryText(memoryText, tags, importance);
+      const memoryEntry = {
+        agentId: runtime.agentId,
+        roomId: message.roomId,
+        userId: message.userId,
+        content: {
+          text: encodedText,
+          source: MEMORY_SOURCE
         },
-        text
+        createdAt: Date.now()
       };
-    } catch (error) {
-      logger4.error({ error }, "Error in longTermMemoryProvider:");
+      await memoryManager.createMemory(memoryEntry, true);
+      const tagSuffix = tags.length > 0 ? ` [tags: ${tags.join(", ")}]` : "";
+      const successMessage = `Remembered: "${memoryText}"${tagSuffix}`;
+      await callback?.({ text: successMessage, source: message.content.source });
       return {
-        data: { memoryCount: 0 },
-        values: { longTermMemories: "" },
-        text: ""
+        text: successMessage,
+        success: true,
+        data: { content: memoryText, tags, importance }
       };
+    } catch (error) {
+      logger3.error("Failed to store memory:", error);
+      const errorMessage = `Failed to store memory: ${error instanceof Error ? error.message : String(error)}`;
+      await callback?.({ text: errorMessage, source: message.content.source });
+      return { text: errorMessage, success: false };
     }
   }
 };
-// src/schemas/index.ts
-var exports_schemas = {};
-__export(exports_schemas, {
-  sessionSummaries: () => sessionSummaries,
-  memoryAccessLogs: () => memoryAccessLogs,
-  longTermMemories: () => longTermMemories
-});
 
-// src/schemas/long-term-memories.ts
-import { sql } from "drizzle-orm";
-import {
-  index,
-  integer,
-  jsonb,
-  pgTable,
-  real,
-  text,
-  timestamp,
-  varchar
-} from "drizzle-orm/pg-core";
-var longTermMemories = pgTable("long_term_memories", {
-  id: varchar("id", { length: 36 }).primaryKey(),
-  agentId: varchar("agent_id", { length: 36 }).notNull(),
-  entityId: varchar("entity_id", { length: 36 }).notNull(),
-  category: text("category").notNull(),
-  content: text("content").notNull(),
-  metadata: jsonb("metadata"),
-  embedding: real("embedding").array(),
-  confidence: real("confidence").default(1),
-  source: text("source"),
-  createdAt: timestamp("created_at").default(sql`now()`).notNull(),
-  updatedAt: timestamp("updated_at").default(sql`now()`).notNull(),
-  lastAccessedAt: timestamp("last_accessed_at"),
-  accessCount: integer("access_count").default(0)
-}, (table) => ({
-  agentEntityIdx: index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
-  categoryIdx: index("long_term_memories_category_idx").on(table.category),
-  confidenceIdx: index("long_term_memories_confidence_idx").on(table.confidence),
-  createdAtIdx: index("long_term_memories_created_at_idx").on(table.createdAt)
-}));
-// src/schemas/memory-access-logs.ts
-import { sql as sql2 } from "drizzle-orm";
-import { index as index2, pgTable as pgTable2, text as text2, timestamp as timestamp2, varchar as varchar2 } from "drizzle-orm/pg-core";
-var memoryAccessLogs = pgTable2("memory_access_logs", {
-  id: varchar2("id", { length: 36 }).primaryKey(),
-  memoryId: varchar2("memory_id", { length: 36 }).notNull(),
-  memoryType: text2("memory_type").notNull(),
-  agentId: varchar2("agent_id", { length: 36 }).notNull(),
-  accessType: text2("access_type").notNull(),
-  accessedAt: timestamp2("accessed_at").default(sql2`now()`).notNull()
-}, (table) => ({
-  memoryIdIdx: index2("memory_access_logs_memory_id_idx").on(table.memoryId),
-  agentIdIdx: index2("memory_access_logs_agent_id_idx").on(table.agentId),
-  accessedAtIdx: index2("memory_access_logs_accessed_at_idx").on(table.accessedAt)
-}));
-// src/schemas/session-summaries.ts
-import { sql as sql3 } from "drizzle-orm";
-import {
-  index as index3,
-  integer as integer2,
-  jsonb as jsonb2,
-  pgTable as pgTable3,
-  real as real2,
-  text as text3,
-  timestamp as timestamp3,
-  varchar as varchar3
-} from "drizzle-orm/pg-core";
-var sessionSummaries = pgTable3("session_summaries", {
-  id: varchar3("id", { length: 36 }).primaryKey(),
-  agentId: varchar3("agent_id", { length: 36 }).notNull(),
-  roomId: varchar3("room_id", { length: 36 }).notNull(),
-  entityId: varchar3("entity_id", { length: 36 }),
-  summary: text3("summary").notNull(),
-  messageCount: integer2("message_count").notNull(),
-  lastMessageOffset: integer2("last_message_offset").notNull().default(0),
-  startTime: timestamp3("start_time").notNull(),
-  endTime: timestamp3("end_time").notNull(),
-  topics: jsonb2("topics"),
-  metadata: jsonb2("metadata"),
-  embedding: real2("embedding").array(),
-  createdAt: timestamp3("created_at").default(sql3`now()`).notNull(),
-  updatedAt: timestamp3("updated_at").default(sql3`now()`).notNull()
-}, (table) => ({
-  agentRoomIdx: index3("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
-  entityIdx: index3("session_summaries_entity_idx").on(table.entityId),
-  startTimeIdx: index3("session_summaries_start_time_idx").on(table.startTime)
-}));
-// src/services/memory-service.ts
-import {
-  logger as logger5,
-  Service
-} from "@elizaos/core";
-import { and, cosineDistance, desc, eq, gte, sql as sql4 } from "drizzle-orm";
-class MemoryService extends Service {
-  static serviceType = "memory";
-  sessionMessageCounts;
-  memoryConfig;
-  lastExtractionCheckpoints;
-  capabilityDescription = "Memory management with short-term summarization and long-term persistent facts";
-  constructor(runtime) {
-    super(runtime);
-    this.sessionMessageCounts = new Map;
-    this.lastExtractionCheckpoints = new Map;
-    this.memoryConfig = {
-      shortTermSummarizationThreshold: 16,
-      shortTermRetainRecent: 6,
-      shortTermSummarizationInterval: 10,
-      longTermExtractionEnabled: true,
-      longTermVectorSearchEnabled: false,
-      longTermConfidenceThreshold: 0.85,
-      longTermExtractionThreshold: 30,
-      longTermExtractionInterval: 10,
-      summaryModelType: "TEXT_LARGE",
-      summaryMaxTokens: 2500,
-      summaryMaxNewMessages: 20
-    };
-  }
-  static async start(runtime) {
-    const service = new MemoryService(runtime);
-    await service.initialize(runtime);
-    return service;
-  }
-  async stop() {
-    logger5.info("MemoryService stopped");
-  }
-  async initialize(runtime) {
-    this.runtime = runtime;
-    const threshold = runtime.getSetting("MEMORY_SUMMARIZATION_THRESHOLD");
-    if (threshold) {
-      this.memoryConfig.shortTermSummarizationThreshold = parseInt(String(threshold), 10);
-    }
-    const retainRecent = runtime.getSetting("MEMORY_RETAIN_RECENT");
-    if (retainRecent) {
-      this.memoryConfig.shortTermRetainRecent = parseInt(String(retainRecent), 10);
-    }
-    const summarizationInterval = runtime.getSetting("MEMORY_SUMMARIZATION_INTERVAL");
-    if (summarizationInterval) {
-      this.memoryConfig.shortTermSummarizationInterval = parseInt(String(summarizationInterval), 10);
-    }
-    const maxNewMessages = runtime.getSetting("MEMORY_MAX_NEW_MESSAGES");
-    if (maxNewMessages) {
-      this.memoryConfig.summaryMaxNewMessages = parseInt(String(maxNewMessages), 10);
-    }
-    const longTermEnabled = runtime.getSetting("MEMORY_LONG_TERM_ENABLED");
-    if (longTermEnabled === "false" || longTermEnabled === false) {
-      this.memoryConfig.longTermExtractionEnabled = false;
-    } else if (longTermEnabled === "true" || longTermEnabled === true) {
-      this.memoryConfig.longTermExtractionEnabled = true;
-    }
-    const confidenceThreshold = runtime.getSetting("MEMORY_CONFIDENCE_THRESHOLD");
-    if (confidenceThreshold) {
-      this.memoryConfig.longTermConfidenceThreshold = parseFloat(String(confidenceThreshold));
-    }
-    const extractionThreshold = runtime.getSetting("MEMORY_EXTRACTION_THRESHOLD");
-    if (extractionThreshold) {
-      this.memoryConfig.longTermExtractionThreshold = parseInt(String(extractionThreshold), 10);
-    }
-    const extractionInterval = runtime.getSetting("MEMORY_EXTRACTION_INTERVAL");
-    if (extractionInterval) {
-      this.memoryConfig.longTermExtractionInterval = parseInt(String(extractionInterval), 10);
-    }
-    logger5.debug({
-      summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
-      summarizationInterval: this.memoryConfig.shortTermSummarizationInterval,
-      maxNewMessages: this.memoryConfig.summaryMaxNewMessages,
-      retainRecent: this.memoryConfig.shortTermRetainRecent,
-      longTermEnabled: this.memoryConfig.longTermExtractionEnabled,
-      extractionThreshold: this.memoryConfig.longTermExtractionThreshold,
-      extractionInterval: this.memoryConfig.longTermExtractionInterval,
-      confidenceThreshold: this.memoryConfig.longTermConfidenceThreshold
-    }, "MemoryService initialized");
-  }
-  getDb() {
-    const db = this.runtime.db;
-    if (!db) {
-      throw new Error("Database not available");
-    }
-    return db;
-  }
-  getConfig() {
-    return { ...this.memoryConfig };
-  }
-  updateConfig(updates) {
-    this.memoryConfig = { ...this.memoryConfig, ...updates };
-  }
-  incrementMessageCount(roomId) {
-    const current = this.sessionMessageCounts.get(roomId) || 0;
-    const newCount = current + 1;
-    this.sessionMessageCounts.set(roomId, newCount);
-    return newCount;
-  }
-  resetMessageCount(roomId) {
-    this.sessionMessageCounts.set(roomId, 0);
-  }
-  async shouldSummarize(roomId) {
-    const count = await this.runtime.countMemories(roomId, false, "messages");
-    return count >= this.memoryConfig.shortTermSummarizationThreshold;
-  }
-  getExtractionKey(entityId, roomId) {
-    return `memory:extraction:${entityId}:${roomId}`;
-  }
-  async getLastExtractionCheckpoint(entityId, roomId) {
-    const key = this.getExtractionKey(entityId, roomId);
-    const cached = this.lastExtractionCheckpoints.get(key);
-    if (cached !== undefined) {
-      return cached;
-    }
-    try {
-      const checkpoint = await this.runtime.getCache(key);
-      const messageCount = checkpoint ?? 0;
-      this.lastExtractionCheckpoints.set(key, messageCount);
-      return messageCount;
-    } catch (error) {
-      logger5.warn({ error }, "Failed to get extraction checkpoint from cache");
-      return 0;
-    }
-  }
-  async setLastExtractionCheckpoint(entityId, roomId, messageCount) {
-    const key = this.getExtractionKey(entityId, roomId);
-    this.lastExtractionCheckpoints.set(key, messageCount);
-    try {
-      await this.runtime.setCache(key, messageCount);
-      logger5.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at count ${messageCount}`);
-    } catch (error) {
-      logger5.error({ error }, "Failed to persist extraction checkpoint to cache");
-    }
-  }
-  async shouldRunExtraction(entityId, roomId, currentMessageCount) {
-    const threshold = this.memoryConfig.longTermExtractionThreshold;
-    const interval = this.memoryConfig.longTermExtractionInterval;
-    if (currentMessageCount < threshold) {
-      return false;
-    }
-    const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
-    const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
-    const shouldRun = currentMessageCount >= threshold && currentCheckpoint > lastCheckpoint;
-    logger5.debug({
-      entityId,
-      roomId,
-      currentMessageCount,
-      threshold,
-      interval,
-      lastCheckpoint,
-      currentCheckpoint,
-      shouldRun
-    }, "Extraction check");
-    return shouldRun;
-  }
-  async storeLongTermMemory(memory) {
-    const db = this.getDb();
-    const id = crypto.randomUUID();
-    const now = new Date;
-    const newMemory = {
-      id,
-      createdAt: now,
-      updatedAt: now,
-      accessCount: 0,
-      ...memory
-    };
-    try {
-      await db.insert(longTermMemories).values({
-        id: newMemory.id,
-        agentId: newMemory.agentId,
-        entityId: newMemory.entityId,
-        category: newMemory.category,
-        content: newMemory.content,
-        metadata: newMemory.metadata || {},
-        embedding: newMemory.embedding,
-        confidence: newMemory.confidence,
-        source: newMemory.source,
-        accessCount: newMemory.accessCount,
-        createdAt: now,
-        updatedAt: now,
-        lastAccessedAt: newMemory.lastAccessedAt
-      });
-    } catch (error) {
-      logger5.error({ error }, "Failed to store long-term memory");
-      throw error;
-    }
-    logger5.info(`Stored long-term memory: ${newMemory.category} for entity ${newMemory.entityId}`);
-    return newMemory;
-  }
-  async getLongTermMemories(entityId, category, limit = 10) {
-    const db = this.getDb();
-    const conditions = [
-      eq(longTermMemories.agentId, this.runtime.agentId),
-      eq(longTermMemories.entityId, entityId)
-    ];
-    if (category) {
-      conditions.push(eq(longTermMemories.category, category));
-    }
-    const results = await db.select().from(longTermMemories).where(and(...conditions)).orderBy(desc(longTermMemories.confidence), desc(longTermMemories.updatedAt)).limit(limit);
-    return results.map((row) => ({
-      id: row.id,
-      agentId: row.agentId,
-      entityId: row.entityId,
-      category: row.category,
-      content: row.content,
-      metadata: row.metadata,
-      embedding: row.embedding,
-      confidence: row.confidence,
-      source: row.source,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt,
-      lastAccessedAt: row.lastAccessedAt,
-      accessCount: row.accessCount
-    }));
-  }
-  async updateLongTermMemory(id, entityId, updates) {
-    const db = this.getDb();
-    const updateData = {
-      updatedAt: new Date
-    };
-    if (updates.content !== undefined)
-      updateData.content = updates.content;
-    if (updates.metadata !== undefined)
-      updateData.metadata = updates.metadata;
-    if (updates.confidence !== undefined)
-      updateData.confidence = updates.confidence;
-    if (updates.embedding !== undefined)
-      updateData.embedding = updates.embedding;
-    if (updates.lastAccessedAt !== undefined)
-      updateData.lastAccessedAt = updates.lastAccessedAt;
-    if (updates.accessCount !== undefined)
-      updateData.accessCount = updates.accessCount;
-    await db.update(longTermMemories).set(updateData).where(and(eq(longTermMemories.id, id), eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.entityId, entityId)));
-    logger5.info(`Updated long-term memory: ${id} for entity ${entityId}`);
-  }
-  async deleteLongTermMemory(id, entityId) {
-    const db = this.getDb();
-    await db.delete(longTermMemories).where(and(eq(longTermMemories.id, id), eq(longTermMemories.agentId, this.runtime.agentId), eq(longTermMemories.entityId, entityId)));
-    logger5.info(`Deleted long-term memory: ${id} for entity ${entityId}`);
-  }
-  async getCurrentSessionSummary(roomId) {
-    const db = this.getDb();
-    const results = await db.select().from(sessionSummaries).where(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(1);
-    if (results.length === 0) {
-      return null;
-    }
-    const row = results[0];
-    return {
-      id: row.id,
-      agentId: row.agentId,
-      roomId: row.roomId,
-      entityId: row.entityId,
-      summary: row.summary,
-      messageCount: row.messageCount,
-      lastMessageOffset: row.lastMessageOffset,
-      startTime: row.startTime,
-      endTime: row.endTime,
-      topics: row.topics || [],
-      metadata: row.metadata,
-      embedding: row.embedding,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    };
-  }
-  async storeSessionSummary(summary) {
-    const db = this.getDb();
-    const id = crypto.randomUUID();
-    const now = new Date;
-    const newSummary = {
-      id,
-      createdAt: now,
-      updatedAt: now,
-      ...summary
-    };
-    await db.insert(sessionSummaries).values({
-      id: newSummary.id,
-      agentId: newSummary.agentId,
-      roomId: newSummary.roomId,
-      entityId: newSummary.entityId || null,
-      summary: newSummary.summary,
-      messageCount: newSummary.messageCount,
-      lastMessageOffset: newSummary.lastMessageOffset,
-      startTime: newSummary.startTime,
-      endTime: newSummary.endTime,
-      topics: newSummary.topics || [],
-      metadata: newSummary.metadata || {},
-      embedding: newSummary.embedding,
-      createdAt: now,
-      updatedAt: now
-    });
-    logger5.info(`Stored session summary for room ${newSummary.roomId}`);
-    return newSummary;
-  }
-  async updateSessionSummary(id, roomId, updates) {
-    const db = this.getDb();
-    const updateData = {
-      updatedAt: new Date
-    };
-    if (updates.summary !== undefined)
-      updateData.summary = updates.summary;
-    if (updates.messageCount !== undefined)
-      updateData.messageCount = updates.messageCount;
-    if (updates.lastMessageOffset !== undefined)
-      updateData.lastMessageOffset = updates.lastMessageOffset;
-    if (updates.endTime !== undefined)
-      updateData.endTime = updates.endTime;
-    if (updates.topics !== undefined)
-      updateData.topics = updates.topics;
-    if (updates.metadata !== undefined)
-      updateData.metadata = updates.metadata;
-    if (updates.embedding !== undefined)
-      updateData.embedding = updates.embedding;
-    await db.update(sessionSummaries).set(updateData).where(and(eq(sessionSummaries.id, id), eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId)));
-    logger5.info(`Updated session summary: ${id} for room ${roomId}`);
-  }
-  async getSessionSummaries(roomId, limit = 5) {
-    const db = this.getDb();
-    const results = await db.select().from(sessionSummaries).where(and(eq(sessionSummaries.agentId, this.runtime.agentId), eq(sessionSummaries.roomId, roomId))).orderBy(desc(sessionSummaries.updatedAt)).limit(limit);
-    return results.map((row) => ({
-      id: row.id,
-      agentId: row.agentId,
-      roomId: row.roomId,
-      entityId: row.entityId,
-      summary: row.summary,
-      messageCount: row.messageCount,
-      lastMessageOffset: row.lastMessageOffset,
-      startTime: row.startTime,
-      endTime: row.endTime,
-      topics: row.topics || [],
-      metadata: row.metadata,
-      embedding: row.embedding,
-      createdAt: row.createdAt,
-      updatedAt: row.updatedAt
-    }));
-  }
-  async searchLongTermMemories(entityId, queryEmbedding, limit = 5, matchThreshold = 0.7) {
-    if (!this.memoryConfig.longTermVectorSearchEnabled) {
-      logger5.warn("Vector search is not enabled, falling back to recent memories");
-      return this.getLongTermMemories(entityId, undefined, limit);
-    }
-    const db = this.getDb();
+// src/providers/memoryContext.ts
+var memoryContextProvider = {
+  name: "MEMORY_CONTEXT",
+  description: "Provides relevant long-term memories from conversation context",
+  get: async (runtime, message, _state) => {
     try {
-      const cleanVector = queryEmbedding.map((n) => Number.isFinite(n) ? Number(n.toFixed(6)) : 0);
-      const similarity = sql4`1 - (${cosineDistance(longTermMemories.embedding, cleanVector)})`;
-      const conditions = [
-        eq(longTermMemories.agentId, this.runtime.agentId),
-        eq(longTermMemories.entityId, entityId),
-        sql4`${longTermMemories.embedding} IS NOT NULL`
-      ];
-      if (matchThreshold > 0) {
-        conditions.push(gte(similarity, matchThreshold));
+      const memoryManager = runtime.getMemoryManager();
+      if (!memoryManager) {
+        return { text: "Memory manager is not available" };
       }
-      const results = await db.select({
-        memory: longTermMemories,
-        similarity
-      }).from(longTermMemories).where(and(...conditions)).orderBy(desc(similarity)).limit(limit);
-      return results.map((row) => ({
-        id: row.memory.id,
-        agentId: row.memory.agentId,
-        entityId: row.memory.entityId,
-        category: row.memory.category,
-        content: row.memory.content,
-        metadata: row.memory.metadata ?? {},
-        embedding: row.memory.embedding ?? [],
-        confidence: row.memory.confidence ?? 1,
-        source: row.memory.source ?? "",
-        createdAt: row.memory.createdAt,
-        updatedAt: row.memory.updatedAt,
-        lastAccessedAt: row.memory.lastAccessedAt ?? row.memory.updatedAt,
-        accessCount: row.memory.accessCount ?? 0,
-        similarity: row.similarity
-      }));
-    } catch (error) {
-      logger5.warn({ error }, "Vector search failed, falling back to recent memories");
-      return this.getLongTermMemories(entityId, undefined, limit);
-    }
-  }
-  async getFormattedLongTermMemories(entityId) {
-    const memories = await this.getLongTermMemories(entityId, undefined, 20);
-    if (memories.length === 0) {
-      return "";
-    }
-    const grouped = new Map;
-    for (const memory of memories) {
-      if (!grouped.has(memory.category)) {
-        grouped.set(memory.category, []);
+      const memories = await memoryManager.getMemories({
+        roomId: message.roomId,
+        count: 50
+      });
+      const pluginMemories = memories.filter((m) => m.content.source === MEMORY_SOURCE);
+      if (pluginMemories.length === 0) {
+        return { text: "No stored memories available" };
       }
-      grouped.get(memory.category)?.push(memory);
-    }
-    const sections = [];
-    for (const [category, categoryMemories] of grouped.entries()) {
-      const categoryName = category.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-      const items = categoryMemories.map((m) => `- ${m.content}`).join(`
-`);
-      sections.push(`**${categoryName}**:
-${items}`);
+      const parsedMemories = pluginMemories.map((m) => {
+        const parsed = decodeMemoryText(m.content.text);
+        return {
+          id: m.id ?? "",
+          content: parsed.content,
+          tags: parsed.tags,
+          importance: parsed.importance,
+          createdAt: m.createdAt ?? 0
+        };
+      }).sort((a, b) => {
+        if (a.importance !== b.importance)
+          return b.importance - a.importance;
+        return b.createdAt - a.createdAt;
+      }).slice(0, 20);
+      const memoryList = parsedMemories.map((m) => {
+        const tagStr = m.tags.length > 0 ? ` [${m.tags.join(", ")}]` : "";
+        const level = IMPORTANCE_LABELS[m.importance] ?? "normal";
+        return `- (${level}) ${m.content}${tagStr}`;
+      });
+      const text = `Stored Memories (${parsedMemories.length}):
+${memoryList.join(`
+`)}`;
+      return {
+        text,
+        data: {
+          memories: parsedMemories.map((m) => ({
+            id: m.id,
+            content: m.content,
+            tags: m.tags,
+            importance: m.importance
+          })),
+          count: parsedMemories.length
+        }
+      };
+    } catch (_error) {
+      return { text: "Error retrieving stored memories" };
     }
-    return sections.join(`
-
-`);
   }
-}
+};
 
 // src/index.ts
 var memoryPlugin = {
-  name: "memory",
-  description: "Memory management with conversation summarization and long-term persistent memory",
-  services: [MemoryService],
-  evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
-  providers: [longTermMemoryProvider, contextSummaryProvider],
-  schema: exports_schemas
+  name: "@elizaos/plugin-memory-ts",
+  description: "Plugin for long-term memory management with remember, recall, and forget capabilities",
+  actions: [rememberAction, recallAction, forgetAction],
+  providers: [memoryContextProvider]
 };
-var src_default = memoryPlugin;
 export {
-  summarizationEvaluator,
-  sessionSummaries,
+  rememberAction,
+  recallAction,
   memoryPlugin,
-  memoryAccessLogs,
-  longTermMemoryProvider,
-  longTermMemories,
-  longTermExtractionEvaluator,
-  src_default as default,
-  contextSummaryProvider,
-  MemoryService,
-  LongTermMemoryCategory
+  memoryContextProvider,
+  forgetAction,
+  encodeMemoryText,
+  decodeMemoryText,
+  MemoryImportance,
+  MEMORY_SOURCE,
+  MEMORY_METADATA_SEPARATOR,
+  IMPORTANCE_LABELS
 };
 
-//# debugId=FC048A8C8739D95E64756E2164756E21
+//# debugId=C7F07CBEF581DD5B64756E2164756E21