@elizaos/plugin-memory 1.1.2 → 2.0.0-alpha

package/dist/cjs/index.node.cjs

@@ -1,1168 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __moduleCache = /* @__PURE__ */ new WeakMap;
-var __toCommonJS = (from) => {
-  var entry = __moduleCache.get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function")
-    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
-      get: () => from[key],
-      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-    }));
-  __moduleCache.set(from, entry);
-  return entry;
-};
-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/index.node.ts
-var exports_index_node = {};
-__export(exports_index_node, {
-  sessionSummaries: () => sessionSummaries,
-  memoryPlugin: () => memoryPlugin,
-  memoryAccessLogs: () => memoryAccessLogs,
-  longTermMemoryProvider: () => longTermMemoryProvider,
-  longTermMemories: () => longTermMemories,
-  default: () => src_default,
-  contextSummaryProvider: () => contextSummaryProvider,
-  MemoryService: () => MemoryService,
-  LongTermMemoryCategory: () => LongTermMemoryCategory
-});
-module.exports = __toCommonJS(exports_index_node);
-
-// src/services/memory-service.ts
-var import_core = require("@elizaos/core");
-var import_drizzle_orm4 = require("drizzle-orm");
-
-// src/schemas/index.ts
-var exports_schemas = {};
-__export(exports_schemas, {
-  sessionSummaries: () => sessionSummaries,
-  memoryAccessLogs: () => memoryAccessLogs,
-  longTermMemories: () => longTermMemories
-});
-
-// src/schemas/long-term-memories.ts
-var import_drizzle_orm = require("drizzle-orm");
-var import_pg_core = require("drizzle-orm/pg-core");
-var longTermMemories = import_pg_core.pgTable("long_term_memories", {
-  id: import_pg_core.varchar("id", { length: 36 }).primaryKey(),
-  agentId: import_pg_core.varchar("agent_id", { length: 36 }).notNull(),
-  entityId: import_pg_core.varchar("entity_id", { length: 36 }).notNull(),
-  category: import_pg_core.text("category").notNull(),
-  content: import_pg_core.text("content").notNull(),
-  metadata: import_pg_core.jsonb("metadata"),
-  embedding: import_pg_core.real("embedding").array(),
-  confidence: import_pg_core.real("confidence").default(1),
-  source: import_pg_core.text("source"),
-  createdAt: import_pg_core.timestamp("created_at").default(import_drizzle_orm.sql`now()`).notNull(),
-  updatedAt: import_pg_core.timestamp("updated_at").default(import_drizzle_orm.sql`now()`).notNull(),
-  lastAccessedAt: import_pg_core.timestamp("last_accessed_at"),
-  accessCount: import_pg_core.integer("access_count").default(0)
-}, (table) => ({
-  agentEntityIdx: import_pg_core.index("long_term_memories_agent_entity_idx").on(table.agentId, table.entityId),
-  categoryIdx: import_pg_core.index("long_term_memories_category_idx").on(table.category),
-  confidenceIdx: import_pg_core.index("long_term_memories_confidence_idx").on(table.confidence),
-  createdAtIdx: import_pg_core.index("long_term_memories_created_at_idx").on(table.createdAt)
-}));
-// src/schemas/session-summaries.ts
-var import_drizzle_orm2 = require("drizzle-orm");
-var import_pg_core2 = require("drizzle-orm/pg-core");
-var sessionSummaries = import_pg_core2.pgTable("session_summaries", {
-  id: import_pg_core2.varchar("id", { length: 36 }).primaryKey(),
-  agentId: import_pg_core2.varchar("agent_id", { length: 36 }).notNull(),
-  roomId: import_pg_core2.varchar("room_id", { length: 36 }).notNull(),
-  entityId: import_pg_core2.varchar("entity_id", { length: 36 }),
-  summary: import_pg_core2.text("summary").notNull(),
-  messageCount: import_pg_core2.integer("message_count").notNull(),
-  lastMessageOffset: import_pg_core2.integer("last_message_offset").notNull().default(0),
-  startTime: import_pg_core2.timestamp("start_time").notNull(),
-  endTime: import_pg_core2.timestamp("end_time").notNull(),
-  topics: import_pg_core2.jsonb("topics"),
-  metadata: import_pg_core2.jsonb("metadata"),
-  embedding: import_pg_core2.real("embedding").array(),
-  createdAt: import_pg_core2.timestamp("created_at").default(import_drizzle_orm2.sql`now()`).notNull(),
-  updatedAt: import_pg_core2.timestamp("updated_at").default(import_drizzle_orm2.sql`now()`).notNull()
-}, (table) => ({
-  agentRoomIdx: import_pg_core2.index("session_summaries_agent_room_idx").on(table.agentId, table.roomId),
-  entityIdx: import_pg_core2.index("session_summaries_entity_idx").on(table.entityId),
-  startTimeIdx: import_pg_core2.index("session_summaries_start_time_idx").on(table.startTime)
-}));
-// src/schemas/memory-access-logs.ts
-var import_drizzle_orm3 = require("drizzle-orm");
-var import_pg_core3 = require("drizzle-orm/pg-core");
-var memoryAccessLogs = import_pg_core3.pgTable("memory_access_logs", {
-  id: import_pg_core3.varchar("id", { length: 36 }).primaryKey(),
-  agentId: import_pg_core3.varchar("agent_id", { length: 36 }).notNull(),
-  memoryId: import_pg_core3.varchar("memory_id", { length: 36 }).notNull(),
-  memoryType: import_pg_core3.text("memory_type").notNull(),
-  accessedAt: import_pg_core3.timestamp("accessed_at").default(import_drizzle_orm3.sql`now()`).notNull(),
-  roomId: import_pg_core3.varchar("room_id", { length: 36 }),
-  relevanceScore: import_pg_core3.real("relevance_score"),
-  wasUseful: import_pg_core3.integer("was_useful")
-}, (table) => ({
-  memoryIdx: import_pg_core3.index("memory_access_logs_memory_idx").on(table.memoryId),
-  agentIdx: import_pg_core3.index("memory_access_logs_agent_idx").on(table.agentId),
-  accessedAtIdx: import_pg_core3.index("memory_access_logs_accessed_at_idx").on(table.accessedAt)
-}));
-// src/services/memory-service.ts
-class MemoryService extends import_core.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() {
-    import_core.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);
-    }
-    import_core.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) {
-      import_core.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);
-      import_core.logger.debug(`Set extraction checkpoint for ${entityId} in room ${roomId} at message count ${messageCount}`);
-    } catch (error) {
-      import_core.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;
-    import_core.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) {
-      import_core.logger.error({ error }, "Failed to store long-term memory");
-      throw error;
-    }
-    import_core.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 = [
-      import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId),
-      import_drizzle_orm4.eq(longTermMemories.entityId, entityId)
-    ];
-    if (category) {
-      conditions.push(import_drizzle_orm4.eq(longTermMemories.category, category));
-    }
-    const results = await db.select().from(longTermMemories).where(import_drizzle_orm4.and(...conditions)).orderBy(import_drizzle_orm4.desc(longTermMemories.confidence), import_drizzle_orm4.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(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
-    import_core.logger.info(`Updated long-term memory: ${id} for entity ${entityId}`);
-  }
-  async deleteLongTermMemory(id, entityId) {
-    const db = this.getDb();
-    await db.delete(longTermMemories).where(import_drizzle_orm4.and(import_drizzle_orm4.eq(longTermMemories.id, id), import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId), import_drizzle_orm4.eq(longTermMemories.entityId, entityId)));
-    import_core.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(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId))).orderBy(import_drizzle_orm4.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
-    });
-    import_core.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(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.id, id), import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId)));
-    import_core.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(import_drizzle_orm4.and(import_drizzle_orm4.eq(sessionSummaries.agentId, this.runtime.agentId), import_drizzle_orm4.eq(sessionSummaries.roomId, roomId))).orderBy(import_drizzle_orm4.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) {
-      import_core.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 = import_drizzle_orm4.sql`1 - (${import_drizzle_orm4.cosineDistance(longTermMemories.embedding, cleanVector)})`;
-      const conditions = [
-        import_drizzle_orm4.eq(longTermMemories.agentId, this.runtime.agentId),
-        import_drizzle_orm4.eq(longTermMemories.entityId, entityId),
-        import_drizzle_orm4.sql`${longTermMemories.embedding} IS NOT NULL`
-      ];
-      if (matchThreshold > 0) {
-        conditions.push(import_drizzle_orm4.gte(similarity, matchThreshold));
-      }
-      const results = await db.select({
-        memory: longTermMemories,
-        similarity
-      }).from(longTermMemories).where(import_drizzle_orm4.and(...conditions)).orderBy(import_drizzle_orm4.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) {
-      import_core.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
-var import_core2 = require("@elizaos/core");
-async function getDialogueMessageCount(runtime, roomId) {
-  const messages = await runtime.getMemories({
-    tableName: "messages",
-    roomId,
-    count: 100,
-    unique: false
-  });
-  const dialogueMessages = messages.filter((msg) => !(msg.content?.type === "action_result" && msg.metadata?.type === "action_result") && (msg.metadata?.type === "agent_response_message" || msg.metadata?.type === "user_message"));
-  return dialogueMessages.length;
-}
-var initialSummarizationTemplate = `# Task: Summarize Conversation
-
-You are analyzing a conversation to create a concise summary that captures the key points, topics, and important details.
-
-# 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: "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) {
-      import_core2.logger.error("MemoryService not found");
-      return;
-    }
-    const config = memoryService.getConfig();
-    const { roomId } = message;
-    try {
-      import_core2.logger.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) {
-        import_core2.logger.debug("No new dialogue messages to summarize");
-        return;
-      }
-      const maxNewMessages = config.summaryMaxNewMessages || 50;
-      const messagesToProcess = Math.min(newDialogueCount, maxNewMessages);
-      if (newDialogueCount > maxNewMessages) {
-        import_core2.logger.warn(`Capping new dialogue messages at ${maxNewMessages} (${newDialogueCount} available). Oldest messages will be skipped.`);
-      }
-      const sortedDialogueMessages = allDialogueMessages.sort((a, b) => (a.createdAt || 0) - (b.createdAt || 0));
-      const newDialogueMessages = sortedDialogueMessages.slice(lastOffset, lastOffset + messagesToProcess);
-      if (newDialogueMessages.length === 0) {
-        import_core2.logger.debug("No new dialogue messages retrieved after filtering");
-        return;
-      }
-      const formattedMessages = newDialogueMessages.map((msg) => {
-        const sender = msg.entityId === runtime.agentId ? runtime.character.name : "User";
-        return `${sender}: ${msg.content.text || "[non-text message]"}`;
-      }).join(`
-`);
-      const state = await runtime.composeState(message);
-      let prompt;
-      let template;
-      if (existingSummary) {
-        template = updateSummarizationTemplate;
-        prompt = import_core2.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 = import_core2.composePromptFromState({
-          state: {
-            ...state,
-            recentMessages: initialMessages
-          },
-          template
-        });
-      }
-      const response = await runtime.useModel(import_core2.ModelType.TEXT_LARGE, {
-        prompt,
-        maxTokens: config.summaryMaxTokens || 2500
-      });
-      const summaryResult = parseSummaryXML(response);
-      import_core2.logger.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
-          }
-        });
-        import_core2.logger.info(`Updated summary for room ${roomId}: ${newDialogueMessages.length} new dialogue messages processed (offset: ${lastOffset} → ${newOffset})`);
-      } else {
-        await memoryService.storeSessionSummary({
-          agentId: runtime.agentId,
-          roomId,
-          entityId: message.entityId !== runtime.agentId ? message.entityId : undefined,
-          summary: summaryResult.summary,
-          messageCount: totalDialogueCount,
-          lastMessageOffset: totalDialogueCount,
-          startTime,
-          endTime,
-          topics: summaryResult.topics,
-          metadata: {
-            keyPoints: summaryResult.keyPoints
-          }
-        });
-        import_core2.logger.info(`Created new summary for room ${roomId}: ${totalDialogueCount} dialogue messages summarized (offset: 0 → ${totalDialogueCount})`);
-      }
-    } catch (error) {
-      import_core2.logger.error({ error }, "Error during summarization:");
-    }
-  },
-  examples: []
-};
-
-// src/evaluators/long-term-extraction.ts
-var import_core3 = require("@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
-
-## 2. SEMANTIC Memory
-General facts, concepts, knowledge, and established truths about the user.
-**Examples:**
-- "User is a senior backend engineer with 8 years experience"
-- "User specializes in distributed systems and microservices architecture"
-- "User's primary programming language is TypeScript"
-- "User works at Acme Corp as technical lead"
-
-**Requirements:**
-- Must be factual, timeless information
-- Must be explicitly stated or demonstrated conclusively
-- No speculation or inference from single instances
-- Core identity, expertise, or knowledge only
-
-## 3. PROCEDURAL Memory
-Skills, workflows, methodologies, and how-to knowledge.
-**Examples:**
-- "User follows strict TDD workflow: write tests first, then implementation"
-- "User prefers git rebase over merge to maintain linear history"
-- "User's debugging process: check logs → reproduce locally → binary search"
-- "User always writes JSDoc comments before implementing functions"
-
-**Requirements:**
-- Must describe HOW user does something
-- Must be a repeated, consistent pattern (seen 3+ times or explicitly stated as standard practice)
-- Must be a workflow, methodology, or skill application
-- Not one-off preferences
-
-# ULTRA-STRICT EXTRACTION CRITERIA
-
-## ✅ DO EXTRACT (Only These):
-
-**EPISODIC:**
-- Significant completed projects or milestones
-- Important bugs, incidents, or problems encountered
-- Major decisions made with lasting impact
-- Formative experiences that shape future work
-
-**SEMANTIC:**
-- Professional identity (role, title, company)
-- Core expertise and specializations (stated explicitly or demonstrated conclusively)
-- Primary languages, frameworks, or tools (not exploratory use)
-- Established facts about their work context
-
-**PROCEDURAL:**
-- Consistent workflows demonstrated 3+ times or explicitly stated
-- Standard practices user always follows
-- Methodology preferences with clear rationale
-- Debugging, testing, or development processes
-
-## ❌ NEVER EXTRACT:
-
-- **One-time requests or tasks** (e.g., "can you generate an image", "help me debug this")
-- **Casual conversations** without lasting significance
-- **Exploratory questions** (e.g., "how does X work?")
-- **Temporary context** (current bug, today's task)
-- **Preferences from single occurrence** (e.g., user asked for code once)
-- **Social pleasantries** (thank you, greetings)
-- **Testing or experimentation** (trying out a feature)
-- **Common patterns everyone has** (likes clear explanations)
-- **Situational information** (working on feature X today)
-- **Opinions without persistence** (single complaint, isolated praise)
-- **General knowledge** (not specific to user)
-
-# Quality Gates (ALL Must Pass)
-
-1. **Significance Test**: Will this matter in 3+ months?
-2. **Specificity Test**: Is this concrete and actionable?
-3. **Evidence Test**: Is there strong evidence (3+ instances OR explicit self-identification)?
-4. **Uniqueness Test**: Is this specific to THIS user (not generic)?
-5. **Confidence Test**: Confidence must be >= 0.85 (be VERY conservative)
-6. **Non-Redundancy Test**: Does this add NEW information not in existing memories?
-
-# Confidence Scoring (Be Conservative)
-
-- **0.95-1.0**: User explicitly stated as core identity/practice AND demonstrated multiple times
-- **0.85-0.94**: User explicitly stated OR consistently demonstrated 5+ times
-- **0.75-0.84**: Strong pattern (3-4 instances) with supporting context
-- **Below 0.75**: DO NOT EXTRACT (insufficient evidence)
-
-# Critical Instructions
-
-1. **Default to NOT extracting** - When in doubt, skip it
-2. **Require overwhelming evidence** - One or two mentions is NOT enough
-3. **Focus on what's PERSISTENT** - Not what's temporary or situational
-4. **Verify against existing memories** - Don't duplicate or contradict
-5. **Maximum 2-3 extractions per run** - Quality over quantity
-
-**If there are no qualifying facts (which is common), respond with <memories></memories>**
-
-# Response Format
-
-<memories>
-  <memory>
-    <category>semantic</category>
-    <content>User is a senior TypeScript developer with 8 years of backend experience</content>
-    <confidence>0.95</confidence>
-  </memory>
-  <memory>
-    <category>procedural</category>
-    <content>User follows TDD workflow: writes tests before implementation, runs tests after each change</content>
-    <confidence>0.88</confidence>
-  </memory>
-  <memory>
-    <category>episodic</category>
-    <content>User led database migration from MongoDB to PostgreSQL for payment system in Q2 2024</content>
-    <confidence>0.92</confidence>
-  </memory>
-</memories>`;
-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)) {
-      import_core3.logger.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) => {
-    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) {
-      import_core3.logger.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) {
-      import_core3.logger.error("MemoryService not found");
-      return;
-    }
-    const config = memoryService.getConfig();
-    const { entityId, roomId } = message;
-    try {
-      import_core3.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 = import_core3.composePromptFromState({
-        state: {
-          ...state,
-          recentMessages: formattedMessages,
-          existingMemories: formattedExisting
-        },
-        template: extractionTemplate
-      });
-      const response = await runtime.useModel(import_core3.ModelType.TEXT_LARGE, {
-        prompt
-      });
-      const extractions = parseMemoryExtractionXML(response);
-      import_core3.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()
-            }
-          });
-          import_core3.logger.info(`Stored long-term memory: [${extraction.category}] ${extraction.content.substring(0, 50)}...`);
-        } else {
-          import_core3.logger.debug(`Skipped low-confidence memory: ${extraction.content} (confidence: ${extraction.confidence}, threshold: ${Math.max(config.longTermConfidenceThreshold, 0.85)})`);
-        }
-      }
-      const currentMessageCount = await runtime.countMemories(roomId, false, "messages");
-      await memoryService.setLastExtractionCheckpoint(entityId, roomId, currentMessageCount);
-      import_core3.logger.debug(`Updated extraction checkpoint to ${currentMessageCount} for entity ${entityId} in room ${roomId}`);
-    } catch (error) {
-      import_core3.logger.error({ error }, "Error during long-term memory extraction:");
-    }
-  },
-  examples: []
-};
-
-// src/providers/long-term-memory.ts
-var import_core4 = require("@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 = import_core4.addHeader("# What I Know About You", formattedMemories);
-      const categoryCounts = new Map;
-      for (const memory of memories) {
-        const count = categoryCounts.get(memory.category) || 0;
-        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) {
-      import_core4.logger.error({ error }, "Error in longTermMemoryProvider:");
-      return {
-        data: { memories: [] },
-        values: { longTermMemories: "" },
-        text: ""
-      };
-    }
-  }
-};
-
-// src/providers/context-summary.ts
-var import_core5 = require("@elizaos/core");
-var contextSummaryProvider = {
-  name: "SUMMARIZED_CONTEXT",
-  description: "Provides summarized context from previous conversations",
-  position: 96,
-  get: async (runtime, message, _state) => {
-    try {
-      const memoryService = runtime.getService("memory");
-      const { roomId } = message;
-      if (!memoryService) {
-        return {
-          data: {
-            summary: null
-          },
-          values: {
-            sessionSummaries: "",
-            sessionSummariesWithTopics: ""
-          },
-          text: ""
-        };
-      }
-      const currentSummary = await memoryService.getCurrentSessionSummary(roomId);
-      if (!currentSummary) {
-        return {
-          data: {
-            summary: null
-          },
-          values: {
-            sessionSummaries: "",
-            sessionSummariesWithTopics: ""
-          },
-          text: ""
-        };
-      }
-      const messageRange = `${currentSummary.messageCount} messages`;
-      const timeRange = new Date(currentSummary.startTime).toLocaleDateString();
-      let summaryOnly = `**Previous Conversation** (${messageRange}, ${timeRange})
-`;
-      summaryOnly += currentSummary.summary;
-      let summaryWithTopics = summaryOnly;
-      if (currentSummary.topics && currentSummary.topics.length > 0) {
-        summaryWithTopics += `
-*Topics: ${currentSummary.topics.join(", ")}*`;
-      }
-      const sessionSummaries2 = import_core5.addHeader("# Conversation Summary", summaryOnly);
-      const sessionSummariesWithTopics = import_core5.addHeader("# Conversation Summary", summaryWithTopics);
-      return {
-        data: {
-          summary: currentSummary
-        },
-        values: {
-          sessionSummaries: sessionSummaries2,
-          sessionSummariesWithTopics
-        },
-        text: sessionSummariesWithTopics
-      };
-    } catch (error) {
-      import_core5.logger.error({ error }, "Error in contextSummaryProvider:");
-      return {
-        data: {
-          summary: null
-        },
-        values: {
-          sessionSummaries: "",
-          sessionSummariesWithTopics: ""
-        },
-        text: ""
-      };
-    }
-  }
-};
-
-// src/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,
-    contextSummaryProvider
-  ],
-  schema: exports_schemas
-};
-var src_default = memoryPlugin;
-
-//# debugId=F9F8FE6AD7DE8BD864756E2164756E21