@elizaos/plugin-experience 2.0.0-alpha.2 → 2.0.0-alpha.4

package/dist/node/index.node.js

@@ -368,7 +368,7 @@ var experienceEvaluator = {
     const messageCount = Number.parseInt(currentCount, 10);
     const newMessageCount = messageCount + 1;
     await runtime.setCache(lastExtractionKey, newMessageCount.toString());
-    const shouldExtract = newMessageCount % 10 === 0;
+    const shouldExtract = newMessageCount % 25 === 0;
     if (shouldExtract) {
       logger2.info(`[experienceEvaluator] Triggering experience extraction after ${newMessageCount} messages`);
     }
@@ -391,21 +391,14 @@ var experienceEvaluator = {
       return;
     }
     const conversationContext = recentMessages.map((m) => m.content.text).filter(Boolean).join(" ");
-    const existingExperiences = await experienceService.queryExperiences({
-      query: conversationContext,
-      limit: 10,
-      minConfidence: 0.7
-    });
-    const existingExperiencesText = existingExperiences.length > 0 ? existingExperiences.map((exp) => `- ${exp.learning}`).join(`
-`) : "None";
     const extractionPrompt = composePrompt({
       state: {
         conversation_context: conversationContext,
-        existing_experiences: existingExperiencesText
+        existing_experiences: "None"
       },
       template: EXTRACT_EXPERIENCES_TEMPLATE
     });
-    const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+    const response = await runtime.useModel(ModelType.TEXT_SMALL, {
       prompt: extractionPrompt
     });
     const experiences = parseExtractedExperiences(response);
@@ -420,6 +413,19 @@ var experienceEvaluator = {
       if (!exp.learning || typeof exp.confidence !== "number" || exp.confidence < threshold) {
         continue;
       }
+      const similar = await experienceService.findSimilarExperiences(exp.learning, 1);
+      if (similar.length > 0) {
+        const existingLearning = similar[0].learning.toLowerCase();
+        const newLearning = exp.learning.toLowerCase();
+        const existingWords = new Set(existingLearning.split(/\s+/).filter((w) => w.length > 3));
+        const newWords = new Set(newLearning.split(/\s+/).filter((w) => w.length > 3));
+        const overlap = [...newWords].filter((w) => existingWords.has(w)).length;
+        const union = new Set([...existingWords, ...newWords]).size;
+        if (union > 0 && overlap / union > 0.6) {
+          logger2.debug(`[experienceEvaluator] Skipping duplicate experience: "${exp.learning.substring(0, 80)}..."`);
+          continue;
+        }
+      }
       const normalizedType = typeof exp.type === "string" ? exp.type.toUpperCase() : "";
       const experienceType = experienceTypeMap[normalizedType] ?? "learning" /* LEARNING */;
       const experienceTag = experienceType;
@@ -756,35 +762,28 @@ class ExperienceService extends Service {
   experiences = new Map;
   experiencesByDomain = new Map;
   experiencesByType = new Map;
-  maxExperiences = 1e4;
+  dirtyExperiences = new Set;
+  persistTimer = null;
   decayManager;
   relationshipManager;
   constructor(runtime) {
     super(runtime);
     this.decayManager = new ConfidenceDecayManager;
     this.relationshipManager = new ExperienceRelationshipManager;
-    const max = getNumberSetting2(runtime, "MAX_EXPERIENCES", this.maxExperiences);
-    if (Number.isFinite(max) && max > 0) {
-      this.maxExperiences = Math.floor(max);
-    }
     this.loadExperiences();
+    this.persistTimer = setInterval(() => {
+      this.persistDirtyExperiences();
+    }, 60000);
   }
   static async start(runtime) {
     const service = new ExperienceService(runtime);
     return service;
   }
-  setMaxExperiences(maxExperiences) {
-    if (!Number.isFinite(maxExperiences) || maxExperiences <= 0)
-      return;
-    this.maxExperiences = Math.floor(maxExperiences);
-  }
   async loadExperiences() {
-    const allMemories = await this.runtime.getMemories({
+    const memories = await this.runtime.getMemories({
       entityId: this.runtime.agentId,
-      count: this.maxExperiences,
-      tableName: "memories"
+      tableName: "experiences"
     });
-    const memories = allMemories.filter((m) => m.content.type === "experience");
     for (const memory of memories) {
       const experienceData = memory.content.data;
       if (experienceData?.id) {
@@ -836,9 +835,19 @@ class ExperienceService extends Service {
   }
   async recordExperience(experienceData) {
     const embeddingText = `${experienceData.context} ${experienceData.action} ${experienceData.result} ${experienceData.learning}`;
-    const embedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
-      text: embeddingText
-    });
+    let embedding;
+    try {
+      const result = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
+        text: embeddingText
+      });
+      if (Array.isArray(result) && result.length > 0 && result.some((v) => v !== 0)) {
+        embedding = result;
+      } else {
+        logger4.warn("[ExperienceService] Embedding model returned empty/zero vector, storing without embedding");
+      }
+    } catch (err) {
+      logger4.warn(`[ExperienceService] Embedding generation failed, storing without embedding: ${err}`);
+    }
     const now = Date.now();
     const experience = {
       id: uuidv4(),
@@ -883,9 +892,6 @@ class ExperienceService extends Service {
         strength: 0.8
       });
     }
-    if (this.experiences.size > this.maxExperiences) {
-      await this.pruneOldExperiences();
-    }
     logger4.info(`[ExperienceService] Recorded experience: ${experience.id} (${experience.type})`);
     return experience;
   }
@@ -915,7 +921,6 @@ class ExperienceService extends Service {
           updatedAt: experience.updatedAt,
           accessCount: experience.accessCount,
           lastAccessedAt: experience.lastAccessedAt,
-          embedding: experience.embedding,
           relatedExperiences: experience.relatedExperiences,
           supersedes: experience.supersedes,
           previousBelief: experience.previousBelief,
@@ -926,88 +931,43 @@ class ExperienceService extends Service {
     };
     await this.runtime.createMemory(memory, "experiences", true);
   }
+  async persistDirtyExperiences() {
+    if (this.dirtyExperiences.size === 0)
+      return;
+    const toSave = Array.from(this.dirtyExperiences);
+    this.dirtyExperiences.clear();
+    let saved = 0;
+    for (const id of toSave) {
+      const exp = this.experiences.get(id);
+      if (exp) {
+        try {
+          await this.saveExperienceToMemory(exp);
+          saved++;
+        } catch {
+          this.dirtyExperiences.add(id);
+        }
+      }
+    }
+    if (saved > 0) {
+      logger4.debug(`[ExperienceService] Persisted ${saved} dirty experiences`);
+    }
+  }
   async queryExperiences(query) {
     let results = [];
+    const limit = query.limit || 10;
     if (query.query) {
-      const similarExperiences = await this.findSimilarExperiences(query.query, query.limit || 10);
-      let candidates = similarExperiences;
-      if (query.type) {
-        const types = Array.isArray(query.type) ? query.type : [query.type];
-        candidates = candidates.filter((exp) => types.includes(exp.type));
-      }
-      if (query.outcome) {
-        candidates = candidates.filter((exp) => exp.outcome === query.outcome);
-      }
-      if (query.domain) {
-        const domains = Array.isArray(query.domain) ? query.domain : [query.domain];
-        candidates = candidates.filter((exp) => domains.includes(exp.domain));
-      }
-      if (query.tags && query.tags.length > 0) {
-        candidates = candidates.filter((exp) => query.tags?.some((tag) => exp.tags.includes(tag)));
-      }
-      if (query.minConfidence !== undefined) {
-        const minConfidence = query.minConfidence;
-        candidates = candidates.filter((exp) => {
-          const decayedConfidence = this.decayManager.getDecayedConfidence(exp);
-          return decayedConfidence >= minConfidence;
-        });
-      }
-      if (query.minImportance !== undefined) {
-        const minImportance = query.minImportance;
-        candidates = candidates.filter((exp) => exp.importance >= minImportance);
-      }
-      if (query.timeRange) {
-        candidates = candidates.filter((exp) => {
-          if (query.timeRange?.start && exp.createdAt < query.timeRange?.start)
-            return false;
-          if (query.timeRange?.end && exp.createdAt > query.timeRange?.end)
-            return false;
-          return true;
-        });
-      }
-      results = candidates;
+      const hasFilters = !!(query.type || query.outcome || query.domain || query.tags && query.tags.length > 0 || query.minConfidence !== undefined || query.minImportance !== undefined || query.timeRange);
+      const fetchLimit = hasFilters ? Math.max(limit * 5, 50) : limit;
+      const candidates = this.applyFilters(await this.findSimilarExperiences(query.query, fetchLimit), query);
+      results = candidates.slice(0, limit);
     } else {
-      let candidates = Array.from(this.experiences.values());
-      if (query.type) {
-        const types = Array.isArray(query.type) ? query.type : [query.type];
-        candidates = candidates.filter((exp) => types.includes(exp.type));
-      }
-      if (query.outcome) {
-        candidates = candidates.filter((exp) => exp.outcome === query.outcome);
-      }
-      if (query.domain) {
-        const domains = Array.isArray(query.domain) ? query.domain : [query.domain];
-        candidates = candidates.filter((exp) => domains.includes(exp.domain));
-      }
-      if (query.tags && query.tags.length > 0) {
-        candidates = candidates.filter((exp) => query.tags?.some((tag) => exp.tags.includes(tag)));
-      }
-      if (query.minConfidence !== undefined) {
-        const minConfidence = query.minConfidence;
-        candidates = candidates.filter((exp) => {
-          const decayedConfidence = this.decayManager.getDecayedConfidence(exp);
-          return decayedConfidence >= minConfidence;
-        });
-      }
-      if (query.minImportance !== undefined) {
-        const minImportance = query.minImportance;
-        candidates = candidates.filter((exp) => exp.importance >= minImportance);
-      }
-      if (query.timeRange) {
-        candidates = candidates.filter((exp) => {
-          if (query.timeRange?.start && exp.createdAt < query.timeRange?.start)
-            return false;
-          if (query.timeRange?.end && exp.createdAt > query.timeRange?.end)
-            return false;
-          return true;
-        });
-      }
+      const candidates = this.applyFilters(Array.from(this.experiences.values()), query);
       candidates.sort((a, b) => {
         const scoreA = this.decayManager.getDecayedConfidence(a) * a.importance;
         const scoreB = this.decayManager.getDecayedConfidence(b) * b.importance;
         return scoreB - scoreA;
       });
-      results = candidates.slice(0, query.limit || 10);
+      results = candidates.slice(0, limit);
     }
     if (query.includeRelated) {
       const relatedIds = new Set;
@@ -1024,31 +984,96 @@ class ExperienceService extends Service {
     for (const exp of results) {
       exp.accessCount++;
       exp.lastAccessedAt = Date.now();
+      this.dirtyExperiences.add(exp.id);
     }
     return results;
   }
+  applyFilters(candidates, query) {
+    let filtered = candidates;
+    if (query.type) {
+      const types = Array.isArray(query.type) ? query.type : [query.type];
+      filtered = filtered.filter((e) => types.includes(e.type));
+    }
+    if (query.outcome) {
+      filtered = filtered.filter((e) => e.outcome === query.outcome);
+    }
+    if (query.domain) {
+      const domains = Array.isArray(query.domain) ? query.domain : [query.domain];
+      filtered = filtered.filter((e) => domains.includes(e.domain));
+    }
+    if (query.tags && query.tags.length > 0) {
+      filtered = filtered.filter((e) => query.tags?.some((t) => e.tags.includes(t)));
+    }
+    if (query.minConfidence !== undefined) {
+      const min = query.minConfidence;
+      filtered = filtered.filter((e) => this.decayManager.getDecayedConfidence(e) >= min);
+    }
+    if (query.minImportance !== undefined) {
+      const min = query.minImportance;
+      filtered = filtered.filter((e) => e.importance >= min);
+    }
+    if (query.timeRange) {
+      const { start, end } = query.timeRange;
+      filtered = filtered.filter((e) => {
+        if (start && e.createdAt < start)
+          return false;
+        if (end && e.createdAt > end)
+          return false;
+        return true;
+      });
+    }
+    return filtered;
+  }
   async findSimilarExperiences(text, limit = 5) {
     if (!text || this.experiences.size === 0) {
       return [];
     }
-    const queryEmbedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
-      text
-    });
-    const similarities = [];
-    for (const experience of this.experiences.values()) {
-      if (experience.embedding) {
-        const similarity = this.cosineSimilarity(queryEmbedding, experience.embedding);
-        similarities.push({ experience, similarity });
+    let queryEmbedding;
+    try {
+      queryEmbedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, { text });
+      if (!Array.isArray(queryEmbedding) || queryEmbedding.length === 0 || queryEmbedding.every((v) => v === 0)) {
+        logger4.warn("[ExperienceService] Query embedding is empty/zero, falling back to recency sort");
+        return this.fallbackSort(limit);
       }
+    } catch {
+      logger4.warn("[ExperienceService] Query embedding failed, falling back to recency sort");
+      return this.fallbackSort(limit);
     }
-    similarities.sort((a, b) => b.similarity - a.similarity);
-    const results = similarities.slice(0, limit).map((item) => item.experience);
+    const SIMILARITY_FLOOR = 0.05;
+    const scored = [];
+    const now = Date.now();
+    for (const experience of this.experiences.values()) {
+      if (!experience.embedding)
+        continue;
+      const similarity = this.cosineSimilarity(queryEmbedding, experience.embedding);
+      if (similarity < SIMILARITY_FLOOR)
+        continue;
+      const decayedConfidence = this.decayManager.getDecayedConfidence(experience);
+      const ageDays = Math.max(0, (now - experience.createdAt) / (24 * 60 * 60 * 1000));
+      const recencyFactor = 1 / (1 + ageDays / 30);
+      const accessFactor = Math.min(1, Math.log2(experience.accessCount + 1) / Math.log2(10));
+      const qualityScore = decayedConfidence * 0.45 + experience.importance * 0.35 + recencyFactor * 0.12 + accessFactor * 0.08;
+      const rerankScore = similarity * 0.7 + qualityScore * 0.3;
+      scored.push({ experience, score: rerankScore });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const results = scored.slice(0, limit).map((item) => item.experience);
     for (const exp of results) {
       exp.accessCount++;
-      exp.lastAccessedAt = Date.now();
+      exp.lastAccessedAt = now;
+      this.dirtyExperiences.add(exp.id);
     }
     return results;
   }
+  fallbackSort(limit) {
+    const all = Array.from(this.experiences.values());
+    all.sort((a, b) => {
+      const sa = this.decayManager.getDecayedConfidence(a) * a.importance;
+      const sb = this.decayManager.getDecayedConfidence(b) * b.importance;
+      return sb - sa;
+    });
+    return all.slice(0, limit);
+  }
   async analyzeExperiences(domain, type) {
     const experiences = await this.queryExperiences({
       domain: domain ? [domain] : undefined,
@@ -1176,63 +1201,26 @@ class ExperienceService extends Service {
     }
     return recommendations.slice(0, 5);
   }
-  async pruneOldExperiences() {
-    if (this.experiences.size <= this.maxExperiences) {
-      return;
-    }
-    const experienceArray = Array.from(this.experiences.values());
-    experienceArray.sort((a, b) => {
-      if (a.importance !== b.importance) {
-        return a.importance - b.importance;
-      }
-      if (a.accessCount !== b.accessCount) {
-        return a.accessCount - b.accessCount;
-      }
-      return a.createdAt - b.createdAt;
-    });
-    const toRemove = experienceArray.slice(0, experienceArray.length - this.maxExperiences);
-    let removedCount = 0;
-    for (const experience of toRemove) {
-      this.experiences.delete(experience.id);
-      const domainSet = this.experiencesByDomain.get(experience.domain);
-      if (domainSet) {
-        domainSet.delete(experience.id);
-        if (domainSet.size === 0) {
-          this.experiencesByDomain.delete(experience.domain);
-        }
-      }
-      const typeSet = this.experiencesByType.get(experience.type);
-      if (typeSet) {
-        typeSet.delete(experience.id);
-        if (typeSet.size === 0) {
-          this.experiencesByType.delete(experience.type);
-        }
-      }
-      removedCount++;
-    }
-    logger4.info(`[ExperienceService] Pruned ${removedCount} old experiences`);
-  }
   async stop() {
     logger4.info("[ExperienceService] Stopping...");
+    if (this.persistTimer) {
+      clearInterval(this.persistTimer);
+      this.persistTimer = null;
+    }
     const experiencesToSave = Array.from(this.experiences.values());
     let savedCount = 0;
     for (const experience of experiencesToSave) {
-      await this.saveExperienceToMemory(experience);
-      savedCount++;
+      try {
+        await this.saveExperienceToMemory(experience);
+        savedCount++;
+      } catch (err) {
+        logger4.warn(`[ExperienceService] Failed to save experience ${experience.id}: ${err}`);
+      }
     }
+    this.dirtyExperiences.clear();
     logger4.info(`[ExperienceService] Saved ${savedCount} experiences`);
   }
 }
-function getNumberSetting2(runtime, key, fallback) {
-  const value = runtime.getSetting(key);
-  if (typeof value === "number")
-    return value;
-  if (typeof value === "string") {
-    const parsed = Number.parseFloat(value);
-    return Number.isFinite(parsed) ? parsed : fallback;
-  }
-  return fallback;
-}
 
 // index.ts
 var experiencePlugin = {
@@ -1244,14 +1232,9 @@ var experiencePlugin = {
   evaluators: [experienceEvaluator],
   async init(config, runtime) {
     logger5.info("[ExperiencePlugin] Initializing experience learning system");
-    const maxExperiences = parseOptionalNumber(config.MAX_EXPERIENCES, 1e4);
     const autoRecordThreshold = parseOptionalNumber(config.AUTO_RECORD_THRESHOLD, 0.7);
-    runtime.setSetting("MAX_EXPERIENCES", maxExperiences.toString());
     runtime.setSetting("AUTO_RECORD_THRESHOLD", autoRecordThreshold.toString());
-    const experienceService = runtime.getService("EXPERIENCE");
-    experienceService?.setMaxExperiences(maxExperiences);
     logger5.info(`[ExperiencePlugin] Configuration:
-    - MAX_EXPERIENCES: ${maxExperiences}
     - AUTO_RECORD_THRESHOLD: ${autoRecordThreshold}`);
   }
 };
@@ -1271,4 +1254,4 @@ export {
   ExperienceService
 };
 
-//# debugId=332CCD4C6A890DF464756E2164756E21
+//# debugId=19BED8D33D8C8ECD64756E2164756E21