@elizaos/plugin-memory 1.0.2

package/dist/node/index.node.js

@@ -0,0 +1,1024 @@
+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/services/memory-service.ts
+import {
+  Service,
+  logger
+} from "@elizaos/core";
+import { eq, and, desc, sql as sql4, cosineDistance, gte } from "drizzle-orm";
+
+// 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 {
+  pgTable,
+  text,
+  integer,
+  jsonb,
+  real,
+  index,
+  varchar,
+  timestamp
+} 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/session-summaries.ts
+import { sql as sql2 } from "drizzle-orm";
+import {
+  pgTable as pgTable2,
+  text as text2,
+  integer as integer2,
+  jsonb as jsonb2,
+  real as real2,
+  index as index2,
+  varchar as varchar2,
+  timestamp as timestamp2
+} from "drizzle-orm/pg-core";
+var sessionSummaries = pgTable2("session_summaries", {
+  id: varchar2("id", { length: 36 }).primaryKey(),
+  agentId: varchar2("agent_id", { length: 36 }).notNull(),
+  roomId: varchar2("room_id", { length: 36 }).notNull(),
+  entityId: varchar2("entity_id", { length: 36 }),
+  summary: text2("summary").notNull(),
+  messageCount: integer2("message_count").notNull(),
+  lastMessageOffset: integer2("last_message_offset").notNull().default(0),
+  startTime: timestamp2("start_time").notNull(),
+  endTime: timestamp2("end_time").notNull(),
+  topics: jsonb2("topics"),
+  metadata: jsonb2("metadata"),
+  embedding: real2("embedding").array(),
+  createdAt: timestamp2("created_at").default(sql2`now()`).notNull(),
+  updatedAt: timestamp2("updated_at").default(sql2`now()`).notNull()
+}, (table) => ({
+  agentRoomIdx: index2("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
+  entityIdx: index2("session_summaries_entity_idx").on(table.entityId),
+  startTimeIdx: index2("session_summaries_start_time_idx").on(table.startTime)
+}));
+// src/schemas/memory-access-logs.ts
+import { sql as sql3 } from "drizzle-orm";
+import { pgTable as pgTable3, text as text3, integer as integer3, real as real3, index as index3, varchar as varchar3, timestamp as timestamp3 } from "drizzle-orm/pg-core";
+var memoryAccessLogs = pgTable3("memory_access_logs", {
+  id: varchar3("id", { length: 36 }).primaryKey(),
+  agentId: varchar3("agent_id", { length: 36 }).notNull(),
+  memoryId: varchar3("memory_id", { length: 36 }).notNull(),
+  memoryType: text3("memory_type").notNull(),
+  accessedAt: timestamp3("accessed_at").default(sql3`now()`).notNull(),
+  roomId: varchar3("room_id", { length: 36 }),
+  relevanceScore: real3("relevance_score"),
+  wasUseful: integer3("was_useful")
+}, (table) => ({
+  memoryIdx: index3("memory_access_logs_memory_idx").on(table.memoryId),
+  agentIdx: index3("memory_access_logs_agent_idx").on(table.agentId),
+  accessedAtIdx: index3("memory_access_logs_accessed_at_idx").on(table.accessedAt)
+}));
+// src/services/memory-service.ts
+class MemoryService extends Service {
+  static serviceType = "memory";
+  sessionMessageCounts;
+  memoryConfig;
+  lastExtractionCheckpoints;
+  capabilityDescription = "Advanced 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: 5,
+      shortTermRetainRecent: 10,
+      longTermExtractionEnabled: true,
+      longTermVectorSearchEnabled: false,
+      longTermConfidenceThreshold: 0.7,
+      longTermExtractionInterval: 5,
+      summaryModelType: "TEXT_LARGE",
+      summaryMaxTokens: 2500
+    };
+  }
+  static async start(runtime) {
+    const service = new MemoryService(runtime);
+    await service.initialize(runtime);
+    return service;
+  }
+  async stop() {
+    logger.info("MemoryService stopped");
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+    const threshold = runtime.getSetting("MEMORY_SUMMARIZATION_THRESHOLD");
+    if (threshold) {
+      this.memoryConfig.shortTermSummarizationThreshold = parseInt(threshold, 10);
+    }
+    const retainRecent = runtime.getSetting("MEMORY_RETAIN_RECENT");
+    if (retainRecent) {
+      this.memoryConfig.shortTermRetainRecent = parseInt(retainRecent, 10);
+    }
+    const longTermEnabled = runtime.getSetting("MEMORY_LONG_TERM_ENABLED");
+    if (longTermEnabled === "false") {
+      this.memoryConfig.longTermExtractionEnabled = false;
+    } else if (longTermEnabled === "true") {
+      this.memoryConfig.longTermExtractionEnabled = true;
+    }
+    const confidenceThreshold = runtime.getSetting("MEMORY_CONFIDENCE_THRESHOLD");
+    if (confidenceThreshold) {
+      this.memoryConfig.longTermConfidenceThreshold = parseFloat(confidenceThreshold);
+    }
+    logger.info({
+      summarizationThreshold: this.memoryConfig.shortTermSummarizationThreshold,
+      retainRecent: this.memoryConfig.shortTermRetainRecent,
+      longTermEnabled: this.memoryConfig.longTermExtractionEnabled,
+      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) {
+      logger.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);
+      logger.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at message count ${messageCount}`);
+    } catch (error) {
+      logger.error({ error }, "Failed to persist extraction checkpoint to cache");
+    }
+  }
+  async shouldRunExtraction(entityId, roomId, currentMessageCount) {
+    const interval = this.memoryConfig.longTermExtractionInterval;
+    const lastCheckpoint = await this.getLastExtractionCheckpoint(entityId, roomId);
+    const currentCheckpoint = Math.floor(currentMessageCount / interval) * interval;
+    const shouldRun = currentMessageCount >= interval && currentCheckpoint > lastCheckpoint;
+    logger.debug({
+      entityId,
+      roomId,
+      currentMessageCount,
+      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) {
+      logger.error({ error }, "Failed to store long-term memory");
+      throw error;
+    }
+    logger.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, 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(eq(longTermMemories.id, id));
+    logger.info(`Updated long-term memory: ${id}`);
+  }
+  async deleteLongTermMemory(id) {
+    const db = this.getDb();
+    await db.delete(longTermMemories).where(eq(longTermMemories.id, id));
+    logger.info(`Deleted long-term memory: ${id}`);
+  }
+  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
+    });
+    logger.info(`Stored session summary for room ${newSummary.roomId}`);
+    return newSummary;
+  }
+  async updateSessionSummary(id, 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(eq(sessionSummaries.id, id));
+    logger.info(`Updated session summary: ${id}`);
+  }
+  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) {
+      logger.warn("Vector search is not enabled, falling back to recent memories");
+      return this.getLongTermMemories(entityId, undefined, limit);
+    }
+    const db = this.getDb();
+    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 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,
+        source: row.memory.source,
+        createdAt: row.memory.createdAt,
+        updatedAt: row.memory.updatedAt,
+        lastAccessedAt: row.memory.lastAccessedAt,
+        accessCount: row.memory.accessCount,
+        similarity: row.similarity
+      }));
+    } catch (error) {
+      logger.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, []);
+      }
+      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}`);
+    }
+    return sections.join(`
+
+`);
+  }
+}
+
+// src/evaluators/summarization.ts
+import {
+  logger as logger2,
+  ModelType,
+  composePromptFromState
+} from "@elizaos/core";
+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 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>`;
+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: "Summarizes conversations to optimize short-term memory",
+  similes: ["CONVERSATION_SUMMARY", "CONTEXT_COMPRESSION", "MEMORY_OPTIMIZATION"],
+  alwaysRun: true,
+  validate: async (runtime, message) => {
+    logger2.debug(`Validating summarization for message: ${message.content?.text}`);
+    if (!message.content?.text) {
+      return false;
+    }
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      return false;
+    }
+    const config = memoryService.getConfig();
+    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
+    const shouldSummarize = currentMessageCount >= config.shortTermSummarizationThreshold;
+    logger2.debug({
+      roomId: message.roomId,
+      currentMessageCount,
+      threshold: config.shortTermSummarizationThreshold,
+      shouldSummarize
+    }, "Summarization check");
+    return shouldSummarize;
+  },
+  handler: async (runtime, message) => {
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      logger2.error("MemoryService not found");
+      return;
+    }
+    const config = memoryService.getConfig();
+    const { roomId } = message;
+    try {
+      logger2.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 newMessages = await runtime.getMemories({
+        tableName: "messages",
+        roomId,
+        count: config.shortTermSummarizationThreshold,
+        unique: false,
+        start: lastOffset
+      });
+      if (newMessages.length === 0) {
+        logger2.debug("No new messages to summarize");
+        return;
+      }
+      const sortedMessages = newMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
+      const formattedMessages = sortedMessages.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 = composePromptFromState({
+          state: {
+            ...state,
+            existingSummary: existingSummary.summary,
+            existingTopics: existingSummary.topics?.join(", ") || "None",
+            newMessages: formattedMessages
+          },
+          template
+        });
+      } else {
+        template = initialSummarizationTemplate;
+        prompt = composePromptFromState({
+          state: {
+            ...state,
+            recentMessages: formattedMessages
+          },
+          template
+        });
+      }
+      const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+        prompt,
+        maxTokens: config.summaryMaxTokens || 2500
+      });
+      const summaryResult = parseSummaryXML(response);
+      logger2.info(`${existingSummary ? "Updated" : "Generated"} summary: ${summaryResult.summary.substring(0, 100)}...`);
+      const newOffset = totalMessageCount;
+      const firstMessage = sortedMessages[0];
+      const lastMessage = sortedMessages[sortedMessages.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, {
+          summary: summaryResult.summary,
+          messageCount: existingSummary.messageCount + sortedMessages.length,
+          lastMessageOffset: newOffset,
+          endTime,
+          topics: summaryResult.topics,
+          metadata: {
+            keyPoints: summaryResult.keyPoints
+          }
+        });
+        logger2.info(`Updated summary for room ${roomId}: ${sortedMessages.length} new 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,
+          startTime,
+          endTime,
+          topics: summaryResult.topics,
+          metadata: {
+            keyPoints: summaryResult.keyPoints
+          }
+        });
+        logger2.info(`Created new summary for room ${roomId}: ${sortedMessages.length} messages summarized (offset: 0 → ${newOffset})`);
+      }
+    } catch (error) {
+      logger2.error({ error }, "Error during summarization:");
+    }
+  },
+  examples: []
+};
+
+// src/evaluators/long-term-extraction.ts
+import {
+  logger as logger3,
+  ModelType as ModelType2,
+  composePromptFromState as composePromptFromState2
+} from "@elizaos/core";
+
+// src/types/index.ts
+var LongTermMemoryCategory;
+((LongTermMemoryCategory2) => {
+  LongTermMemoryCategory2["IDENTITY"] = "identity";
+  LongTermMemoryCategory2["EXPERTISE"] = "expertise";
+  LongTermMemoryCategory2["PROJECTS"] = "projects";
+  LongTermMemoryCategory2["PREFERENCES"] = "preferences";
+  LongTermMemoryCategory2["DATA_SOURCES"] = "data_sources";
+  LongTermMemoryCategory2["GOALS"] = "goals";
+  LongTermMemoryCategory2["CONSTRAINTS"] = "constraints";
+  LongTermMemoryCategory2["DEFINITIONS"] = "definitions";
+  LongTermMemoryCategory2["BEHAVIORAL_PATTERNS"] = "behavioral_patterns";
+})(LongTermMemoryCategory ||= {});
+
+// src/evaluators/long-term-extraction.ts
+var extractionTemplate = `# Task: Extract Long-Term Memory
+
+You are analyzing a conversation to extract facts that should be remembered long-term about the user.
+
+# Recent Messages
+{{recentMessages}}
+
+# Current Long-Term Memories
+{{existingMemories}}
+
+# Memory Categories
+1. **identity**: User's name, role, identity (e.g., "I'm a data scientist")
+2. **expertise**: User's skills, knowledge domains, or unfamiliarity with topics
+3. **projects**: Ongoing projects, past interactions, recurring topics
+4. **preferences**: Communication style, format preferences, verbosity, etc.
+5. **data_sources**: Frequently used files, databases, APIs
+6. **goals**: Broader intentions (e.g., "preparing for interview")
+7. **constraints**: User-defined rules or limitations
+8. **definitions**: Custom terms, acronyms, glossaries
+9. **behavioral_patterns**: How the user tends to interact
+
+# Instructions
+Extract any NEW information that should be remembered long-term. For each item:
+- Determine which category it belongs to
+- Write a clear, factual statement
+- Assess confidence (0.0 to 1.0)
+- Only include information explicitly stated or strongly implied
+
+If there are no new long-term facts to extract, respond with <memories></memories>
+
+Respond in this XML format:
+<memories>
+  <memory>
+    <category>identity</category>
+    <content>User is a software engineer specializing in backend development</content>
+    <confidence>0.95</confidence>
+  </memory>
+  <memory>
+    <category>preferences</category>
+    <content>Prefers code examples over lengthy explanations</content>
+    <confidence>0.85</confidence>
+  </memory>
+</memories>`;
+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)) {
+      logger3.warn(`Invalid memory category: ${category}`);
+      continue;
+    }
+    if (content && !isNaN(confidence)) {
+      extractions.push({ category, content, confidence });
+    }
+  }
+  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) => {
+    logger3.debug(`Validating long-term memory extraction for message: ${message.content?.text}`);
+    if (message.entityId === runtime.agentId) {
+      logger3.debug("Skipping long-term memory extraction for agent's own message");
+      return false;
+    }
+    if (!message.content?.text) {
+      logger3.debug("Skipping long-term memory extraction for message without text");
+      return false;
+    }
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      logger3.debug("MemoryService not found");
+      return false;
+    }
+    const config = memoryService.getConfig();
+    if (!config.longTermExtractionEnabled) {
+      logger3.debug("Long-term memory extraction is disabled");
+      return false;
+    }
+    const currentMessageCount = await runtime.countMemories(message.roomId, false, "messages");
+    const shouldRun = await memoryService.shouldRunExtraction(message.entityId, message.roomId, currentMessageCount);
+    logger3.debug(`Should run extraction: ${shouldRun}`);
+    return shouldRun;
+  },
+  handler: async (runtime, message) => {
+    const memoryService = runtime.getService("memory");
+    if (!memoryService) {
+      logger3.error("MemoryService not found");
+      return;
+    }
+    const config = memoryService.getConfig();
+    const { entityId, roomId } = message;
+    try {
+      logger3.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 = composePromptFromState2({
+        state: {
+          ...state,
+          recentMessages: formattedMessages,
+          existingMemories: formattedExisting
+        },
+        template: extractionTemplate
+      });
+      const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+        prompt
+      });
+      const extractions = parseMemoryExtractionXML(response);
+      logger3.info(`Extracted ${extractions.length} long-term memories`);
+      for (const extraction of extractions) {
+        if (extraction.confidence >= config.longTermConfidenceThreshold) {
+          await memoryService.storeLongTermMemory({
+            agentId: runtime.agentId,
+            entityId,
+            category: extraction.category,
+            content: extraction.content,
+            confidence: extraction.confidence,
+            source: "conversation",
+            metadata: {
+              roomId,
+              extractedAt: new Date().toISOString()
+            }
+          });
+          logger3.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
+        } else {
+          logger3.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence})`);
+        }
+      }
+      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
+      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
+      logger3.debug(`Updated extraction checkpoint to ${currentMessageCount} for entity ${entityId} in room ${roomId}`);
+    } catch (error) {
+      logger3.error({ error }, "Error during long-term memory extraction:");
+    }
+  },
+  examples: []
+};
+
+// src/providers/short-term-memory.ts
+import {
+  logger as logger4,
+  addHeader
+} from "@elizaos/core";
+var shortTermMemoryProvider = {
+  name: "SHORT_TERM_MEMORY",
+  description: "Recent conversation summaries to maintain context efficiently",
+  position: 95,
+  get: async (runtime, message, _state) => {
+    try {
+      const memoryService = runtime.getService("memory");
+      if (!memoryService) {
+        return {
+          data: { summaries: [] },
+          values: { sessionSummaries: "" },
+          text: ""
+        };
+      }
+      const { roomId } = message;
+      const summaries = await memoryService.getSessionSummaries(roomId, 3);
+      if (summaries.length === 0) {
+        return {
+          data: { summaries: [] },
+          values: { sessionSummaries: "" },
+          text: ""
+        };
+      }
+      const formattedSummaries = summaries.reverse().map((summary, index4) => {
+        const messageRange = `${summary.messageCount} messages`;
+        const timeRange = new Date(summary.startTime).toLocaleDateString();
+        let text5 = `**Session ${index4 + 1}** (${messageRange}, ${timeRange})
+`;
+        text5 += summary.summary;
+        if (summary.topics && summary.topics.length > 0) {
+          text5 += `
+*Topics: ${summary.topics.join(", ")}*`;
+        }
+        return text5;
+      }).join(`
+
+`);
+      const text4 = addHeader("# Previous Conversation Context", formattedSummaries);
+      return {
+        data: { summaries },
+        values: { sessionSummaries: text4 },
+        text: text4
+      };
+    } catch (error) {
+      logger4.error({ error }, "Error in shortTermMemoryProvider:");
+      return {
+        data: { summaries: [] },
+        values: { sessionSummaries: "" },
+        text: ""
+      };
+    }
+  }
+};
+
+// src/providers/long-term-memory.ts
+import {
+  logger as logger5,
+  addHeader as addHeader2
+} 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: { memories: [] },
+          values: { longTermMemories: "" },
+          text: ""
+        };
+      }
+      const { entityId } = message;
+      if (entityId === runtime.agentId) {
+        return {
+          data: { memories: [] },
+          values: { longTermMemories: "" },
+          text: ""
+        };
+      }
+      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
+      if (memories.length === 0) {
+        return {
+          data: { memories: [] },
+          values: { longTermMemories: "" },
+          text: ""
+        };
+      }
+      const formattedMemories = await memoryService.getFormattedLongTermMemories(entityId);
+      const text4 = 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 categoryList = Array.from(categoryCounts.entries()).map(([cat, count]) => `${cat}: ${count}`).join(", ");
+      return {
+        data: {
+          memories,
+          categoryCounts: Object.fromEntries(categoryCounts)
+        },
+        values: {
+          longTermMemories: text4,
+          memoryCategories: categoryList
+        },
+        text: text4
+      };
+    } catch (error) {
+      logger5.error({ error }, "Error in longTermMemoryProvider:");
+      return {
+        data: { memories: [] },
+        values: { longTermMemories: "" },
+        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],
+  schema: exports_schemas
+};
+var src_default = memoryPlugin;
+export {
+  sessionSummaries,
+  memoryPlugin,
+  memoryAccessLogs,
+  longTermMemories,
+  src_default as default,
+  MemoryService,
+  LongTermMemoryCategory
+};
+
+//# debugId=97E9763BD19A053564756E2164756E21