@elizaos/plugin-memory 1.1.2 → 2.0.0-alpha

package/dist/{node/index.node.js → index.js}

@@ -9,536 +9,15 @@ var __export = (target, all) => {
     });
 };
 
-// src/services/memory-service.ts
+// src/evaluators/long-term-extraction.ts
 import {
-  Service,
-  logger
+  composePromptFromState,
+  logger,
+  ModelType
 } 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: 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() {
-    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 summarizationInterval = runtime.getSetting("MEMORY_SUMMARIZATION_INTERVAL");
-    if (summarizationInterval) {
-      this.memoryConfig.shortTermSummarizationInterval = parseInt(summarizationInterval, 10);
-    }
-    const maxNewMessages = runtime.getSetting("MEMORY_MAX_NEW_MESSAGES");
-    if (maxNewMessages) {
-      this.memoryConfig.summaryMaxNewMessages = parseInt(maxNewMessages, 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);
-    }
-    const extractionThreshold = runtime.getSetting("MEMORY_EXTRACTION_THRESHOLD");
-    if (extractionThreshold) {
-      this.memoryConfig.longTermExtractionThreshold = parseInt(extractionThreshold, 10);
-    }
-    const extractionInterval = runtime.getSetting("MEMORY_EXTRACTION_INTERVAL");
-    if (extractionInterval) {
-      this.memoryConfig.longTermExtractionInterval = parseInt(extractionInterval, 10);
-    }
-    logger.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) {
-      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 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;
-    logger.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) {
-      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, 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)));
-    logger.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)));
-    logger.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
-    });
-    logger.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)));
-    logger.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) {
-      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";
-async function getDialogueMessageCount(runtime, roomId) {
-  const messages = await runtime.getMemories({
-    tableName: "messages",
-    roomId,
-    count: 100,
-    unique: false
-  });
-  const dialogueMessages = messages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
-  return dialogueMessages.length;
-}
-var initialSummarizationTemplate = `# Task: Summarize Conversation
+// 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.
 
@@ -568,232 +47,29 @@ Respond in this XML format:
     <point>Second key point</point>
   </keyPoints>
 </summary>`;
-var updateSummarizationTemplate = `# Task: Update and Condense Conversation Summary
+var longTermExtractionTemplate = `# Task: Extract Long-Term Memory (Strict Criteria)
 
-You are updating an existing conversation summary with new messages, while keeping the total summary concise.
+You are analyzing a conversation to extract ONLY the most critical, persistent information about the user using cognitive science memory categories.
 
-# Existing Summary
-{{existingSummary}}
+# Recent Messages
+{{recentMessages}}
 
-# Existing Topics
-{{existingTopics}}
+# Current Long-Term Memories
+{{existingMemories}}
 
-# New Messages Since Last Summary
-{{newMessages}}
+# Memory Categories (Based on Cognitive Science)
 
-# 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
+## 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"
 
-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: "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) {
-      const shouldSummarize = currentDialogueCount >= config.shortTermSummarizationThreshold;
-      return shouldSummarize;
-    } else {
-      const newDialogueCount = currentDialogueCount - existingSummary.lastMessageOffset;
-      const shouldUpdate = newDialogueCount >= config.shortTermSummarizationInterval;
-      return shouldUpdate;
-    }
-  },
-  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 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 maxNewMessages = config.summaryMaxNewMessages || 50;
-      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
-      if (newDialogueCount > maxNewMessages) {
-        logger2.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available). Oldest messages will be skipped.`);
-      }
-      const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
-      if (newDialogueMessages.length === 0) {
-        logger2.debug("No new dialogue messages retrieved after filtering");
-        return;
-      }
-      const formattedMessages = newDialogueMessages.map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
-`);
-      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 {
-        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 = composePromptFromState({
-          state: {
-            ...state,
-            recentMessages: initialMessages
-          },
-          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 = 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} new dialogue messages processed (offset: ${lastOffset} → ${newOffset})`);
-      } else {
-        await memoryService.storeSessionSummary({
-          agentId: runtime.agentId,
-          roomId,
-          entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
-          summary: summaryResult.summary,
-          messageCount: totalDialogueCount,
-          lastMessageOffset: totalDialogueCount,
-          startTime,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: {
-            keyPoints: summaryResult.keyPoints
-          }
-        });
-        logger2.info(`Created new summary for room ${roomId}: ${totalDialogueCount} dialogue messages summarized (offset: 0 → ${totalDialogueCount})`);
-      }
-    } 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["EPISODIC"] = "episodic";
-  LongTermMemoryCategory2["SEMANTIC"] = "semantic";
-  LongTermMemoryCategory2["PROCEDURAL"] = "procedural";
-})(LongTermMemoryCategory ||= {});
-
-// src/evaluators/long-term-extraction.ts
-var extractionTemplate = `# 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
+**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.
@@ -904,6 +180,49 @@ Skills, workflows, methodologies, and how-to knowledge.
     <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 = [];
@@ -912,271 +231,903 @@ function parseMemoryExtractionXML(xml) {
     const content = match[2].trim();
     const confidence = parseFloat(match[3].trim());
     if (!Object.values(LongTermMemoryCategory).includes(category)) {
-      logger3.warn(`Invalid memory category: ${category}`);
+      logger.warn(`Invalid memory category: ${category}`);
       continue;
     }
-    if (content && !isNaN(confidence)) {
+    if (content && !Number.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) => {
-    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) {
-      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);
-    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 >= 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()
-            }
-          });
-          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}, threshold: ${Math.max(config.longTermConfidenceThreshold, 0.85)})`);
-        }
-      }
-      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:");
+  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})`);
+        }
+      }
+      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;
+    }
+  },
+  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 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 maxNewMessages = config.summaryMaxNewMessages || 50;
+      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
+      if (newDialogueCount > maxNewMessages) {
+        logger2.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available)`);
+      }
+      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 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 response = await runtime.useModel(ModelType2.TEXT_LARGE, {
+        prompt,
+        maxTokens: config.summaryMaxTokens || 2500
+      });
+      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`);
+      }
+    } catch (error) {
+      logger2.error({ error }, "Error during summarization:");
+    }
+    return;
+  },
+  examples: []
+};
+// src/providers/context-summary.ts
+import {
+  addHeader,
+  logger as logger3
+} from "@elizaos/core";
+var contextSummaryProvider = {
+  name: "SUMMARIZED_CONTEXT",
+  description: "Provides summarized context from previous conversations",
+  position: 96,
+  get: async (runtime, message, _state) => {
+    try {
+      const memoryService = runtime.getService("memory");
+      const { roomId } = message;
+      if (!memoryService) {
+        return {
+          data: {},
+          values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+          text: ""
+        };
+      }
+      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
+      if (!currentSummary) {
+        return {
+          data: {},
+          values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+          text: ""
+        };
+      }
+      const messageRange = `${currentSummary.messageCount} messages`;
+      const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
+      let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})
+`;
+      summaryOnly += currentSummary.summary;
+      let summaryWithTopics = summaryOnly;
+      if (currentSummary.topics && currentSummary.topics.length > 0) {
+        summaryWithTopics += `
+*Topics: ${currentSummary.topics.join(", ")}*`;
+      }
+      const sessionSummaries = addHeader("# Conversation Summary", summaryOnly);
+      const sessionSummariesWithTopics = addHeader("# Conversation Summary", summaryWithTopics);
+      return {
+        data: {
+          summaryText: currentSummary.summary,
+          messageCount: currentSummary.messageCount,
+          topics: currentSummary.topics?.join(", ") || ""
+        },
+        values: { sessionSummaries, sessionSummariesWithTopics },
+        text: sessionSummariesWithTopics
+      };
+    } catch (error) {
+      logger3.error({ error }, "Error in contextSummaryProvider:");
+      return {
+        data: {},
+        values: { sessionSummaries: "", sessionSummariesWithTopics: "" },
+        text: ""
+      };
+    }
+  }
+};
+// src/providers/long-term-memory.ts
+import {
+  addHeader as addHeader2,
+  logger as logger4
+} 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: ""
+        };
+      }
+      const { entityId } = message;
+      if (entityId === runtime.agentId) {
+        return {
+          data: { memoryCount: 0 },
+          values: { longTermMemories: "" },
+          text: ""
+        };
+      }
+      const memories = await memoryService.getLongTermMemories(entityId, undefined, 25);
+      if (memories.length === 0) {
+        return {
+          data: { memoryCount: 0 },
+          values: { longTermMemories: "" },
+          text: ""
+        };
+      }
+      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 categoryList = Array.from(categoryCounts.entries()).map(([cat, count]) => `${cat}: ${count}`).join(", ");
+      return {
+        data: {
+          memoryCount: memories.length,
+          categories: categoryList
+        },
+        values: {
+          longTermMemories: text,
+          memoryCategories: categoryList
+        },
+        text
+      };
+    } catch (error) {
+      logger4.error({ error }, "Error in longTermMemoryProvider:");
+      return {
+        data: { memoryCount: 0 },
+        values: { longTermMemories: "" },
+        text: ""
+      };
+    }
+  }
+};
+// 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);
     }
-  },
-  examples: []
-};
-
-// src/providers/long-term-memory.ts
-import {
-  logger as logger4,
-  addHeader
-} from "@elizaos/core";
-var longTermMemoryProvider = {
-  name: "LONG_TERM_MEMORY",
-  description: "Persistent facts and preferences about the user",
-  position: 50,
-  get: async (runtime, message, _state) => {
+    const db = this.getDb();
     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 = addHeader("# 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 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 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
-      };
+      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) {
-      logger4.error({ error }, "Error in longTermMemoryProvider:");
-      return {
-        data: { memories: [] },
-        values: { longTermMemories: "" },
-        text: ""
-      };
+      logger5.warn({ error }, "Vector search failed, falling back to recent memories");
+      return this.getLongTermMemories(entityId, undefined, limit);
     }
   }
-};
-
-// src/providers/context-summary.ts
-import {
-  addHeader as addHeader2,
-  logger as logger5
-} from "@elizaos/core";
-var contextSummaryProvider = {
-  name: "SUMMARIZED_CONTEXT",
-  description: "Provides summarized context from previous conversations",
-  position: 96,
-  get: async (runtime, message, _state) => {
-    try {
-      const memoryService = runtime.getService("memory");
-      const { roomId } = message;
-      if (!memoryService) {
-        return {
-          data: {
-            summary: null
-          },
-          values: {
-            sessionSummaries: "",
-            sessionSummariesWithTopics: ""
-          },
-          text: ""
-        };
-      }
-      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
-      if (!currentSummary) {
-        return {
-          data: {
-            summary: null
-          },
-          values: {
-            sessionSummaries: "",
-            sessionSummariesWithTopics: ""
-          },
-          text: ""
-        };
-      }
-      const messageRange = `${currentSummary.messageCount} messages`;
-      const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
-      let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})
-`;
-      summaryOnly += currentSummary.summary;
-      let summaryWithTopics = summaryOnly;
-      if (currentSummary.topics && currentSummary.topics.length > 0) {
-        summaryWithTopics += `
-*Topics: ${currentSummary.topics.join(", ")}*`;
+  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 sessionSummaries2 = addHeader2("# Conversation Summary", summaryOnly);
-      const sessionSummariesWithTopics = addHeader2("# Conversation Summary", summaryWithTopics);
-      return {
-        data: {
-          summary: currentSummary
-        },
-        values: {
-          sessionSummaries: sessionSummaries2,
-          sessionSummariesWithTopics
-        },
-        text: sessionSummariesWithTopics
-      };
-    } catch (error) {
-      logger5.error({ error }, "Error in contextSummaryProvider:");
-      return {
-        data: {
-          summary: null
-        },
-        values: {
-          sessionSummaries: "",
-          sessionSummariesWithTopics: ""
-        },
-        text: ""
-      };
+      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/index.ts
 var memoryPlugin = {
   name: "memory",
-  description: "Advanced memory management with conversation summarization and long-term persistent memory",
+  description: "Memory management with conversation summarization and long-term persistent memory",
   services: [MemoryService],
   evaluators: [summarizationEvaluator, longTermExtractionEvaluator],
-  providers: [
-    longTermMemoryProvider,
-    contextSummaryProvider
-  ],
+  providers: [longTermMemoryProvider, contextSummaryProvider],
   schema: exports_schemas
 };
 var src_default = memoryPlugin;
 export {
+  summarizationEvaluator,
   sessionSummaries,
   memoryPlugin,
   memoryAccessLogs,
   longTermMemoryProvider,
   longTermMemories,
+  longTermExtractionEvaluator,
   src_default as default,
   contextSummaryProvider,
   MemoryService,
   LongTermMemoryCategory
 };
 
-//# debugId=6798CB2FB52CC5AF64756E2164756E21
+//# debugId=FC048A8C8739D95E64756E2164756E21