@elizaos/plugin-experience 2.0.0-alpha.1

package/dist/node/index.node.js

@@ -0,0 +1,1274 @@
+// index.ts
+import { logger as logger5 } from "@elizaos/core";
+
+// actions/record-experience.ts
+import {
+  createUniqueUuid,
+  logger
+} from "@elizaos/core";
+
+// generated/specs/specs.ts
+var coreActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "RECORD_EXPERIENCE",
+      description: "Record a learning or experience for future reference. Use this when the user explicitly asks you to remember something or when you've learned something important.",
+      similes: ["REMEMBER", "LEARN", "STORE_EXPERIENCE", "SAVE_EXPERIENCE", "RECORD_LEARNING"],
+      parameters: [],
+      examples: [
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Remember that installing dependencies is required for Python scripts"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "I'll record that experience. Learning: Need to install dependencies before running Python scripts.",
+              actions: ["RECORD_EXPERIENCE"]
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Remember that users prefer shorter responses"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "I'll remember that preference.",
+              actions: ["RECORD_EXPERIENCE"]
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "What's 2+2?"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "2+2 equals 4."
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Can you help me with math?"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "Of course! What math problem do you need help with?"
+            }
+          }
+        ]
+      ]
+    }
+  ]
+};
+var allActionsSpec = {
+  version: "1.0.0",
+  actions: [
+    {
+      name: "RECORD_EXPERIENCE",
+      description: "Record a learning or experience for future reference. Use this when the user explicitly asks you to remember something or when you've learned something important.",
+      similes: ["REMEMBER", "LEARN", "STORE_EXPERIENCE", "SAVE_EXPERIENCE", "RECORD_LEARNING"],
+      parameters: [],
+      examples: [
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Remember that installing dependencies is required for Python scripts"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "I'll record that experience. Learning: Need to install dependencies before running Python scripts.",
+              actions: ["RECORD_EXPERIENCE"]
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Remember that users prefer shorter responses"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "I'll remember that preference.",
+              actions: ["RECORD_EXPERIENCE"]
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "What's 2+2?"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "2+2 equals 4."
+            }
+          }
+        ],
+        [
+          {
+            name: "{{name1}}",
+            content: {
+              text: "Can you help me with math?"
+            }
+          },
+          {
+            name: "{{name2}}",
+            content: {
+              text: "Of course! What math problem do you need help with?"
+            }
+          }
+        ]
+      ]
+    }
+  ]
+};
+var coreProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "experienceProvider",
+      description: "Provides relevant past experiences and learnings for the current context",
+      dynamic: true
+    }
+  ]
+};
+var allProvidersSpec = {
+  version: "1.0.0",
+  providers: [
+    {
+      name: "experienceProvider",
+      description: "Provides relevant past experiences and learnings for the current context",
+      dynamic: true
+    }
+  ]
+};
+var coreEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var allEvaluatorsSpec = {
+  version: "1.0.0",
+  evaluators: []
+};
+var coreActionDocs = coreActionsSpec.actions;
+var allActionDocs = allActionsSpec.actions;
+var coreProviderDocs = coreProvidersSpec.providers;
+var allProviderDocs = allProvidersSpec.providers;
+var coreEvaluatorDocs = coreEvaluatorsSpec.evaluators;
+var allEvaluatorDocs = allEvaluatorsSpec.evaluators;
+
+// generated/specs/spec-helpers.ts
+var coreActionMap = new Map(coreActionDocs.map((doc) => [doc.name, doc]));
+var allActionMap = new Map(allActionDocs.map((doc) => [doc.name, doc]));
+var coreProviderMap = new Map(coreProviderDocs.map((doc) => [doc.name, doc]));
+var allProviderMap = new Map(allProviderDocs.map((doc) => [doc.name, doc]));
+var coreEvaluatorMap = new Map(coreEvaluatorDocs.map((doc) => [doc.name, doc]));
+var allEvaluatorMap = new Map(allEvaluatorDocs.map((doc) => [doc.name, doc]));
+function getActionSpec(name) {
+  return coreActionMap.get(name) ?? allActionMap.get(name);
+}
+function requireActionSpec(name) {
+  const spec = getActionSpec(name);
+  if (!spec) {
+    throw new Error(`Action spec not found: ${name}`);
+  }
+  return spec;
+}
+function getProviderSpec(name) {
+  return coreProviderMap.get(name) ?? allProviderMap.get(name);
+}
+function requireProviderSpec(name) {
+  const spec = getProviderSpec(name);
+  if (!spec) {
+    throw new Error(`Provider spec not found: ${name}`);
+  }
+  return spec;
+}
+
+// actions/record-experience.ts
+var spec = requireActionSpec("RECORD_EXPERIENCE");
+var recordExperienceAction = {
+  name: spec.name,
+  similes: spec.similes ? [...spec.similes] : [],
+  description: spec.description,
+  examples: spec.examples ?? [],
+  async validate(_runtime, message) {
+    const text = message.content.text?.toLowerCase();
+    return text?.includes("remember") || text?.includes("record") || false;
+  },
+  async handler(runtime, message, state, _options, _callback) {
+    logger.info("Recording experience for message:", message.id);
+    const experienceMemory = {
+      id: createUniqueUuid(runtime, `experience-${message.id}`),
+      entityId: message.entityId,
+      agentId: runtime.agentId,
+      roomId: message.roomId,
+      content: {
+        text: message.content.text,
+        source: message.content.source,
+        type: "experience",
+        context: state?.text
+      },
+      createdAt: Date.now()
+    };
+    await runtime.createMemory(experienceMemory, "experiences", true);
+    logger.info("Experience recorded successfully");
+    return {
+      success: true,
+      text: "Experience recorded.",
+      data: {
+        experienceMemoryId: experienceMemory.id
+      }
+    };
+  }
+};
+
+// evaluators/experienceEvaluator.ts
+import {
+  composePrompt,
+  logger as logger2,
+  ModelType
+} from "@elizaos/core";
+
+// generated/prompts/typescript/prompts.ts
+var extractExperiencesTemplate = `# Task: Extract Novel Learning Experiences
+
+Analyze this conversation for novel learning experiences that would be surprising or valuable to remember.
+
+## Conversation context
+{{conversation_context}}
+
+## Existing similar experiences
+{{existing_experiences}}
+
+## Instructions
+Extract ONLY experiences that are:
+1. Genuinely novel (not in existing experiences)
+2. Actionable learnings about how things work
+3. Corrections of previous mistakes or assumptions
+4. Discoveries of new capabilities or patterns
+5. Surprising outcomes that contradict expectations
+
+Focus on technical knowledge, patterns, and cause-effect relationships that transfer to other contexts.
+Avoid personal details, user-specific information, or routine interactions.
+
+Respond with JSON array of experiences (max 3):
+[{
+  "type": "DISCOVERY|CORRECTION|SUCCESS|LEARNING",
+  "learning": "What was learned (generic, transferable)",
+  "context": "What situation triggered this (anonymized)",
+  "confidence": 0.0-1.0,
+  "reasoning": "Why this is novel and valuable"
+}]
+
+Return empty array [] if no novel experiences found.`;
+var EXTRACT_EXPERIENCES_TEMPLATE = extractExperiencesTemplate;
+
+// types.ts
+var ExperienceServiceType = {
+  EXPERIENCE: "EXPERIENCE"
+};
+var ExperienceType;
+((ExperienceType2) => {
+  ExperienceType2["SUCCESS"] = "success";
+  ExperienceType2["FAILURE"] = "failure";
+  ExperienceType2["DISCOVERY"] = "discovery";
+  ExperienceType2["CORRECTION"] = "correction";
+  ExperienceType2["LEARNING"] = "learning";
+  ExperienceType2["HYPOTHESIS"] = "hypothesis";
+  ExperienceType2["VALIDATION"] = "validation";
+  ExperienceType2["WARNING"] = "warning";
+})(ExperienceType ||= {});
+var OutcomeType;
+((OutcomeType2) => {
+  OutcomeType2["POSITIVE"] = "positive";
+  OutcomeType2["NEGATIVE"] = "negative";
+  OutcomeType2["NEUTRAL"] = "neutral";
+  OutcomeType2["MIXED"] = "mixed";
+})(OutcomeType ||= {});
+
+// evaluators/experienceEvaluator.ts
+var experienceEvaluator = {
+  name: "EXPERIENCE_EVALUATOR",
+  similes: ["experience recorder", "learning evaluator", "self-reflection"],
+  description: "Periodically analyzes conversation patterns to extract novel learning experiences",
+  alwaysRun: false,
+  examples: [
+    {
+      prompt: "The agent successfully executed a shell command after initially failing",
+      messages: [
+        {
+          name: "Autoliza",
+          content: {
+            text: "Let me try to run this Python script."
+          }
+        },
+        {
+          name: "Autoliza",
+          content: {
+            text: "Error: ModuleNotFoundError for pandas. I need to install it first."
+          }
+        },
+        {
+          name: "Autoliza",
+          content: {
+            text: "After installing pandas, the script ran successfully and produced the expected output."
+          }
+        }
+      ],
+      outcome: "Record a CORRECTION experience about needing to install dependencies before running Python scripts"
+    },
+    {
+      prompt: "The agent discovered a new system capability",
+      messages: [
+        {
+          name: "Autoliza",
+          content: {
+            text: "I found that the system has jq installed, which is perfect for parsing JSON data."
+          }
+        }
+      ],
+      outcome: "Record a DISCOVERY experience about the availability of jq for JSON processing"
+    }
+  ],
+  async validate(runtime, message, _state) {
+    if (message.entityId !== runtime.agentId) {
+      return false;
+    }
+    const lastExtractionKey = "experience-extraction:last-message-count";
+    const currentCount = await runtime.getCache(lastExtractionKey) || "0";
+    const messageCount = Number.parseInt(currentCount, 10);
+    const newMessageCount = messageCount + 1;
+    await runtime.setCache(lastExtractionKey, newMessageCount.toString());
+    const shouldExtract = newMessageCount % 10 === 0;
+    if (shouldExtract) {
+      logger2.info(`[experienceEvaluator] Triggering experience extraction after ${newMessageCount} messages`);
+    }
+    return shouldExtract;
+  },
+  async handler(runtime, message, state, _options, _callback, _responses) {
+    const experienceService = runtime.getService("EXPERIENCE");
+    if (!experienceService) {
+      logger2.warn("[experienceEvaluator] Experience service not available");
+      return;
+    }
+    const recentMessages = await runtime.getMemories({
+      tableName: "messages",
+      roomId: message.roomId,
+      count: 10,
+      unique: false
+    });
+    if (recentMessages.length < 3) {
+      logger2.debug("[experienceEvaluator] Not enough messages for experience extraction");
+      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
+      },
+      template: EXTRACT_EXPERIENCES_TEMPLATE
+    });
+    const response = await runtime.useModel(ModelType.TEXT_LARGE, {
+      prompt: extractionPrompt
+    });
+    const experiences = parseExtractedExperiences(response);
+    const threshold = getNumberSetting(runtime, "AUTO_RECORD_THRESHOLD", 0.6);
+    const experienceTypeMap = {
+      DISCOVERY: "discovery" /* DISCOVERY */,
+      CORRECTION: "correction" /* CORRECTION */,
+      SUCCESS: "success" /* SUCCESS */,
+      LEARNING: "learning" /* LEARNING */
+    };
+    for (const exp of experiences.slice(0, 3)) {
+      if (!exp.learning || typeof exp.confidence !== "number" || exp.confidence < threshold) {
+        continue;
+      }
+      const normalizedType = typeof exp.type === "string" ? exp.type.toUpperCase() : "";
+      const experienceType = experienceTypeMap[normalizedType] ?? "learning" /* LEARNING */;
+      const experienceTag = experienceType;
+      await experienceService.recordExperience({
+        type: experienceType,
+        outcome: experienceType === "correction" /* CORRECTION */ ? "positive" /* POSITIVE */ : "neutral" /* NEUTRAL */,
+        context: sanitizeContext(exp.context || "Conversation analysis"),
+        action: "pattern_recognition",
+        result: exp.learning,
+        learning: sanitizeContext(exp.learning),
+        domain: detectDomain(exp.learning),
+        tags: ["extracted", "novel", experienceTag],
+        confidence: Math.min(exp.confidence, 0.9),
+        importance: 0.8
+      });
+      logger2.info(`[experienceEvaluator] Recorded novel experience: ${exp.learning.substring(0, 100)}...`);
+    }
+    if (experiences.length > 0) {
+      logger2.info(`[experienceEvaluator] Extracted ${experiences.length} novel experiences from conversation`);
+    } else {
+      logger2.debug("[experienceEvaluator] No novel experiences found in recent conversation");
+    }
+    return {
+      success: true,
+      data: {
+        extractedCount: experiences.length
+      },
+      values: {
+        extractedCount: experiences.length.toString()
+      }
+    };
+  }
+};
+function parseExtractedExperiences(response) {
+  const jsonMatch = response.match(/\[[\s\S]*\]/);
+  if (!jsonMatch)
+    return [];
+  try {
+    const parsed = JSON.parse(jsonMatch[0]);
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter((item) => item && typeof item === "object");
+  } catch {
+    return [];
+  }
+}
+function getNumberSetting(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;
+}
+function sanitizeContext(text) {
+  if (!text)
+    return "Unknown context";
+  return text.replace(/\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b/g, "[EMAIL]").replace(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g, "[IP]").replace(/\/Users\/[^/\s]+/g, "/Users/[USER]").replace(/\/home\/[^/\s]+/g, "/home/[USER]").replace(/\b[A-Z0-9]{20,}\b/g, "[TOKEN]").replace(/\b(user|person|someone|they)\s+(said|asked|told|mentioned)/gi, "when asked").substring(0, 200);
+}
+function detectDomain(text) {
+  const domains = {
+    shell: ["command", "terminal", "bash", "shell", "execute", "script", "cli"],
+    coding: [
+      "code",
+      "function",
+      "variable",
+      "syntax",
+      "programming",
+      "debug",
+      "typescript",
+      "javascript"
+    ],
+    system: ["file", "directory", "process", "memory", "cpu", "system", "install", "package"],
+    network: ["http", "api", "request", "response", "url", "network", "fetch", "curl"],
+    data: ["json", "csv", "database", "query", "data", "sql", "table"],
+    ai: ["model", "llm", "embedding", "prompt", "token", "inference"]
+  };
+  const lowerText = text.toLowerCase();
+  for (const [domain, keywords] of Object.entries(domains)) {
+    if (keywords.some((keyword) => lowerText.includes(keyword))) {
+      return domain;
+    }
+  }
+  return "general";
+}
+
+// providers/experienceProvider.ts
+import {
+  logger as logger3
+} from "@elizaos/core";
+var spec2 = requireProviderSpec("experienceProvider");
+var experienceProvider = {
+  name: spec2.name,
+  description: "Provides relevant past experiences and learnings for the current context",
+  async get(runtime, message, _state) {
+    const experienceService = runtime.getService("EXPERIENCE");
+    if (!experienceService) {
+      return { text: "", data: {}, values: {} };
+    }
+    const messageText = message.content.text || "";
+    if (messageText.length < 10) {
+      return { text: "", data: {}, values: {} };
+    }
+    const relevantExperiences = await experienceService.queryExperiences({
+      query: messageText,
+      limit: 5,
+      minConfidence: 0.6,
+      minImportance: 0.5
+    });
+    if (relevantExperiences.length === 0) {
+      return { text: "", data: {}, values: {} };
+    }
+    const experienceText = relevantExperiences.map((exp, index) => {
+      return `Experience ${index + 1}: In ${exp.domain} context, when ${exp.context}, I learned: ${exp.learning}`;
+    }).join(`
+`);
+    const contextText = `[RELEVANT EXPERIENCES]
+${experienceText}
+[/RELEVANT EXPERIENCES]`;
+    logger3.debug(`[experienceProvider] Injecting ${relevantExperiences.length} relevant experiences`);
+    return {
+      text: contextText,
+      data: {
+        experiences: relevantExperiences,
+        count: relevantExperiences.length
+      },
+      values: {
+        experienceCount: relevantExperiences.length.toString()
+      }
+    };
+  }
+};
+
+// service.ts
+import {
+  logger as logger4,
+  ModelType as ModelType2,
+  Service
+} from "@elizaos/core";
+import { v4 as uuidv4 } from "uuid";
+
+// utils/confidenceDecay.ts
+var DEFAULT_DECAY_CONFIG = {
+  halfLife: 30 * 24 * 60 * 60 * 1000,
+  minConfidence: 0.1,
+  decayStartDelay: 7 * 24 * 60 * 60 * 1000
+};
+
+class ConfidenceDecayManager {
+  config;
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_DECAY_CONFIG, ...config };
+  }
+  getDecayedConfidence(experience) {
+    const now = Date.now();
+    const age = now - experience.createdAt;
+    const specificConfig = this.getDomainSpecificDecay(experience);
+    if (age < specificConfig.decayStartDelay) {
+      return experience.confidence;
+    }
+    const decayTime = age - specificConfig.decayStartDelay;
+    const halfLives = decayTime / specificConfig.halfLife;
+    const decayFactor = 0.5 ** halfLives;
+    const decayedConfidence = experience.confidence * decayFactor;
+    return Math.max(specificConfig.minConfidence, decayedConfidence);
+  }
+  getExperiencesNeedingReinforcement(experiences, threshold = 0.3) {
+    return experiences.filter((exp) => {
+      const decayed = this.getDecayedConfidence(exp);
+      return decayed < threshold && decayed > this.config.minConfidence;
+    });
+  }
+  calculateReinforcementBoost(experience, validationStrength = 1) {
+    const currentConfidence = this.getDecayedConfidence(experience);
+    const boost = (1 - currentConfidence) * validationStrength * 0.5;
+    return Math.min(1, currentConfidence + boost);
+  }
+  getDomainSpecificDecay(experience) {
+    const config = { ...this.config };
+    if (experience.type === "discovery" /* DISCOVERY */ || experience.type === "learning" /* LEARNING */) {
+      config.halfLife *= 2;
+    }
+    if (experience.type === "warning" /* WARNING */ || experience.type === "correction" /* CORRECTION */) {
+      config.halfLife *= 1.5;
+      config.minConfidence = 0.2;
+    }
+    switch (experience.domain) {
+      case "security":
+      case "safety":
+        config.halfLife *= 3;
+        config.minConfidence = 0.3;
+        break;
+      case "performance":
+        config.halfLife *= 0.5;
+        break;
+      case "user_preference":
+        config.halfLife *= 0.7;
+        break;
+    }
+    return config;
+  }
+  getConfidenceTrend(experience, points = 10) {
+    const trend = [];
+    const now = Date.now();
+    const totalTime = now - experience.createdAt;
+    const interval = totalTime / (points - 1);
+    const specificConfig = this.getDomainSpecificDecay(experience);
+    for (let i = 0;i < points; i++) {
+      const timestamp = experience.createdAt + interval * i;
+      const age = timestamp - experience.createdAt;
+      let confidence;
+      if (age < specificConfig.decayStartDelay) {
+        confidence = experience.confidence;
+      } else {
+        const decayTime = age - specificConfig.decayStartDelay;
+        const halfLives = decayTime / specificConfig.halfLife;
+        const decayFactor = 0.5 ** halfLives;
+        confidence = Math.max(specificConfig.minConfidence, experience.confidence * decayFactor);
+      }
+      trend.push({ timestamp, confidence });
+    }
+    return trend;
+  }
+}
+
+// utils/experienceRelationships.ts
+class ExperienceRelationshipManager {
+  relationships = new Map;
+  addRelationship(relationship) {
+    const { fromId } = relationship;
+    if (!this.relationships.has(fromId)) {
+      this.relationships.set(fromId, []);
+    }
+    this.relationships.get(fromId)?.push(relationship);
+  }
+  findRelationships(experienceId, type) {
+    const rels = this.relationships.get(experienceId) || [];
+    if (type) {
+      return rels.filter((r) => r.type === type);
+    }
+    return rels;
+  }
+  detectCausalChain(experiences) {
+    const chains = [];
+    const sorted = [...experiences].sort((a, b) => a.createdAt - b.createdAt);
+    for (let i = 0;i < sorted.length - 1; i++) {
+      const current = sorted[i];
+      if (!current) {
+        continue;
+      }
+      if (current.type === "hypothesis" /* HYPOTHESIS */) {
+        const chain = [current.id];
+        let j = i + 1;
+        while (j < sorted.length) {
+          const next = sorted[j];
+          if (!next) {
+            j++;
+            continue;
+          }
+          if (next.relatedExperiences?.includes(current.id) || this.isRelated(current, next)) {
+            chain.push(next.id);
+            if (next.type === "validation" /* VALIDATION */) {
+              chains.push({
+                rootExperience: current.id,
+                chain,
+                strength: next.confidence,
+                validated: next.outcome === "positive" /* POSITIVE */
+              });
+              break;
+            }
+          }
+          j++;
+        }
+      }
+    }
+    return chains;
+  }
+  isRelated(exp1, exp2) {
+    if (exp1.domain === exp2.domain) {
+      const timeDiff = Math.abs(exp2.createdAt - exp1.createdAt);
+      if (timeDiff < 5 * 60 * 1000) {
+        if (this.contentSimilarity(exp1, exp2) > 0.7) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  contentSimilarity(exp1, exp2) {
+    const words1 = new Set(exp1.learning.toLowerCase().split(/\s+/));
+    const words2 = new Set(exp2.learning.toLowerCase().split(/\s+/));
+    const intersection = new Set([...words1].filter((x) => words2.has(x)));
+    const union = new Set([...words1, ...words2]);
+    return intersection.size / union.size;
+  }
+  findContradictions(experience, allExperiences) {
+    const contradictions = [];
+    for (const other of allExperiences) {
+      if (other.id === experience.id)
+        continue;
+      if (other.action === experience.action && other.outcome !== experience.outcome && other.domain === experience.domain) {
+        contradictions.push(other);
+      }
+      const rels = this.findRelationships(experience.id, "contradicts");
+      if (rels.some((r) => r.toId === other.id)) {
+        contradictions.push(other);
+      }
+    }
+    return contradictions;
+  }
+  getExperienceImpact(experienceId, allExperiences) {
+    let impact = 0;
+    for (const exp of allExperiences) {
+      if (exp.relatedExperiences?.includes(experienceId)) {
+        impact += exp.importance;
+      }
+    }
+    const relationships = this.findRelationships(experienceId);
+    for (const rel of relationships) {
+      if (rel.type === "causes") {
+        impact += rel.strength;
+      }
+    }
+    return impact;
+  }
+}
+
+// service.ts
+class ExperienceService extends Service {
+  static serviceType = ExperienceServiceType.EXPERIENCE;
+  capabilityDescription = "Manages agent experiences, learning from successes and failures to improve future decisions";
+  experiences = new Map;
+  experiencesByDomain = new Map;
+  experiencesByType = new Map;
+  maxExperiences = 1e4;
+  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();
+  }
+  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({
+      entityId: this.runtime.agentId,
+      count: this.maxExperiences,
+      tableName: "memories"
+    });
+    const memories = allMemories.filter((m) => m.content.type === "experience");
+    for (const memory of memories) {
+      const experienceData = memory.content.data;
+      if (experienceData?.id) {
+        const memoryCreatedAt = typeof memory.createdAt === "number" ? memory.createdAt : Date.now();
+        const toTimestamp = (value, fallback) => {
+          if (value === undefined)
+            return fallback;
+          if (typeof value === "number")
+            return value;
+          if (value instanceof Date)
+            return value.getTime();
+          return fallback;
+        };
+        const experience = {
+          id: experienceData.id,
+          agentId: this.runtime.agentId,
+          type: experienceData.type || "learning" /* LEARNING */,
+          outcome: experienceData.outcome || "neutral" /* NEUTRAL */,
+          context: experienceData.context || "",
+          action: experienceData.action || "",
+          result: experienceData.result || "",
+          learning: experienceData.learning || "",
+          domain: experienceData.domain || "general",
+          tags: experienceData.tags || [],
+          confidence: experienceData.confidence || 0.5,
+          importance: experienceData.importance || 0.5,
+          createdAt: toTimestamp(experienceData.createdAt, memoryCreatedAt),
+          updatedAt: toTimestamp(experienceData.updatedAt, memoryCreatedAt),
+          accessCount: experienceData.accessCount ?? 0,
+          lastAccessedAt: toTimestamp(experienceData.lastAccessedAt, memoryCreatedAt),
+          embedding: experienceData.embedding,
+          relatedExperiences: experienceData.relatedExperiences,
+          supersedes: experienceData.supersedes,
+          previousBelief: experienceData.previousBelief,
+          correctedBelief: experienceData.correctedBelief
+        };
+        this.experiences.set(experience.id, experience);
+        if (!this.experiencesByDomain.has(experience.domain)) {
+          this.experiencesByDomain.set(experience.domain, new Set);
+        }
+        this.experiencesByDomain.get(experience.domain)?.add(experience.id);
+        if (!this.experiencesByType.has(experience.type)) {
+          this.experiencesByType.set(experience.type, new Set);
+        }
+        this.experiencesByType.get(experience.type)?.add(experience.id);
+      }
+    }
+    logger4.info(`[ExperienceService] Loaded ${this.experiences.size} experiences from memory`);
+  }
+  async recordExperience(experienceData) {
+    const embeddingText = `${experienceData.context} ${experienceData.action} ${experienceData.result} ${experienceData.learning}`;
+    const embedding = await this.runtime.useModel(ModelType2.TEXT_EMBEDDING, {
+      text: embeddingText
+    });
+    const now = Date.now();
+    const experience = {
+      id: uuidv4(),
+      agentId: this.runtime.agentId,
+      type: experienceData.type || "learning" /* LEARNING */,
+      outcome: experienceData.outcome || "neutral" /* NEUTRAL */,
+      context: experienceData.context || "",
+      action: experienceData.action || "",
+      result: experienceData.result || "",
+      learning: experienceData.learning || "",
+      domain: experienceData.domain || "general",
+      tags: experienceData.tags || [],
+      confidence: experienceData.confidence || 0.5,
+      importance: experienceData.importance || 0.5,
+      createdAt: now,
+      updatedAt: now,
+      accessCount: 0,
+      lastAccessedAt: now,
+      embedding,
+      relatedExperiences: experienceData.relatedExperiences,
+      supersedes: experienceData.supersedes,
+      previousBelief: experienceData.previousBelief,
+      correctedBelief: experienceData.correctedBelief
+    };
+    this.experiences.set(experience.id, experience);
+    if (!this.experiencesByDomain.has(experience.domain)) {
+      this.experiencesByDomain.set(experience.domain, new Set);
+    }
+    this.experiencesByDomain.get(experience.domain)?.add(experience.id);
+    if (!this.experiencesByType.has(experience.type)) {
+      this.experiencesByType.set(experience.type, new Set);
+    }
+    this.experiencesByType.get(experience.type)?.add(experience.id);
+    await this.saveExperienceToMemory(experience);
+    const allExperiences = Array.from(this.experiences.values());
+    const contradictions = this.relationshipManager.findContradictions(experience, allExperiences);
+    for (const contradiction of contradictions) {
+      this.relationshipManager.addRelationship({
+        fromId: experience.id,
+        toId: contradiction.id,
+        type: "contradicts",
+        strength: 0.8
+      });
+    }
+    if (this.experiences.size > this.maxExperiences) {
+      await this.pruneOldExperiences();
+    }
+    logger4.info(`[ExperienceService] Recorded experience: ${experience.id} (${experience.type})`);
+    return experience;
+  }
+  async saveExperienceToMemory(experience) {
+    const memory = {
+      id: experience.id,
+      entityId: this.runtime.agentId,
+      agentId: this.runtime.agentId,
+      roomId: this.runtime.agentId,
+      content: {
+        text: `Experience: ${experience.learning}`,
+        type: "experience",
+        data: {
+          id: experience.id,
+          agentId: experience.agentId,
+          type: experience.type,
+          outcome: experience.outcome,
+          context: experience.context,
+          action: experience.action,
+          result: experience.result,
+          learning: experience.learning,
+          domain: experience.domain,
+          tags: experience.tags,
+          confidence: experience.confidence,
+          importance: experience.importance,
+          createdAt: experience.createdAt,
+          updatedAt: experience.updatedAt,
+          accessCount: experience.accessCount,
+          lastAccessedAt: experience.lastAccessedAt,
+          embedding: experience.embedding,
+          relatedExperiences: experience.relatedExperiences,
+          supersedes: experience.supersedes,
+          previousBelief: experience.previousBelief,
+          correctedBelief: experience.correctedBelief
+        }
+      },
+      createdAt: experience.createdAt
+    };
+    await this.runtime.createMemory(memory, "experiences", true);
+  }
+  async queryExperiences(query) {
+    let results = [];
+    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;
+    } 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;
+        });
+      }
+      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);
+    }
+    if (query.includeRelated) {
+      const relatedIds = new Set;
+      for (const exp of results) {
+        if (exp.relatedExperiences) {
+          exp.relatedExperiences.forEach((id) => {
+            relatedIds.add(id);
+          });
+        }
+      }
+      const related = Array.from(relatedIds).map((id) => this.experiences.get(id)).filter((exp) => exp !== undefined).filter((exp) => !results.some((r) => r.id === exp.id));
+      results.push(...related);
+    }
+    for (const exp of results) {
+      exp.accessCount++;
+      exp.lastAccessedAt = Date.now();
+    }
+    return results;
+  }
+  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 });
+      }
+    }
+    similarities.sort((a, b) => b.similarity - a.similarity);
+    const results = similarities.slice(0, limit).map((item) => item.experience);
+    for (const exp of results) {
+      exp.accessCount++;
+      exp.lastAccessedAt = Date.now();
+    }
+    return results;
+  }
+  async analyzeExperiences(domain, type) {
+    const experiences = await this.queryExperiences({
+      domain: domain ? [domain] : undefined,
+      type: type ? [type] : undefined,
+      limit: 100
+    });
+    if (experiences.length === 0) {
+      return {
+        pattern: "No experiences found for analysis",
+        frequency: 0,
+        reliability: 0,
+        alternatives: [],
+        recommendations: []
+      };
+    }
+    const learnings = experiences.map((exp) => exp.learning);
+    const commonWords = this.findCommonPatterns(learnings);
+    const avgConfidence = experiences.reduce((sum, exp) => sum + exp.confidence, 0) / experiences.length;
+    const outcomeConsistency = this.calculateOutcomeConsistency(experiences);
+    const reliability = (avgConfidence + outcomeConsistency) / 2;
+    const alternatives = this.extractAlternatives(experiences);
+    const recommendations = this.generateRecommendations(experiences, reliability);
+    return {
+      pattern: commonWords.length > 0 ? `Common patterns: ${commonWords.join(", ")}` : "No clear patterns detected",
+      frequency: experiences.length,
+      reliability,
+      alternatives,
+      recommendations
+    };
+  }
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length)
+      return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0;i < a.length; i++) {
+      const valueA = a[i] ?? 0;
+      const valueB = b[i] ?? 0;
+      dotProduct += valueA * valueB;
+      normA += valueA * valueA;
+      normB += valueB * valueB;
+    }
+    if (normA === 0 || normB === 0)
+      return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+  findCommonPatterns(texts) {
+    const wordFreq = new Map;
+    for (const text of texts) {
+      const words = text.toLowerCase().split(/\s+/);
+      for (const word of words) {
+        if (word.length > 3) {
+          wordFreq.set(word, (wordFreq.get(word) || 0) + 1);
+        }
+      }
+    }
+    const threshold = texts.length * 0.3;
+    return Array.from(wordFreq.entries()).filter(([_, count]) => count >= threshold).sort((a, b) => b[1] - a[1]).slice(0, 5).map(([word]) => word);
+  }
+  calculateOutcomeConsistency(experiences) {
+    if (experiences.length === 0)
+      return 0;
+    const outcomeCounts = new Map;
+    for (const exp of experiences) {
+      outcomeCounts.set(exp.outcome, (outcomeCounts.get(exp.outcome) || 0) + 1);
+    }
+    const maxCount = Math.max(...outcomeCounts.values());
+    return maxCount / experiences.length;
+  }
+  extractAlternatives(experiences) {
+    const alternatives = new Set;
+    for (const exp of experiences) {
+      if (exp.type === "correction" /* CORRECTION */ && exp.correctedBelief) {
+        alternatives.add(exp.correctedBelief);
+      }
+      if (exp.outcome === "negative" /* NEGATIVE */ && exp.learning.includes("instead")) {
+        const match = exp.learning.match(/instead\s+(.+?)(?:\.|$)/i);
+        const alternative = match?.[1]?.trim();
+        if (alternative) {
+          alternatives.add(alternative);
+        }
+      }
+    }
+    return Array.from(alternatives).slice(0, 5);
+  }
+  generateRecommendations(experiences, reliability) {
+    const recommendations = [];
+    if (reliability > 0.8) {
+      recommendations.push("Continue using successful approaches");
+      recommendations.push("Document and share these reliable methods");
+    } else if (reliability > 0.6) {
+      recommendations.push("Continue using successful approaches with caution");
+      recommendations.push("Monitor for potential issues");
+      recommendations.push("Consider backup strategies");
+    } else if (reliability > 0.4) {
+      recommendations.push("Review and improve current approaches");
+      recommendations.push("Investigate failure patterns");
+      recommendations.push("Consider alternative methods");
+    } else {
+      recommendations.push("Significant changes needed to current approach");
+      recommendations.push("Analyze failure causes thoroughly");
+      recommendations.push("Seek alternative solutions");
+    }
+    const failureTypes = new Map;
+    experiences.filter((e) => e.outcome === "negative" /* NEGATIVE */).forEach((e) => {
+      const key = e.learning.toLowerCase();
+      failureTypes.set(key, (failureTypes.get(key) || 0) + 1);
+    });
+    if (failureTypes.size > 0) {
+      const mostCommonFailure = Array.from(failureTypes.entries()).sort((a, b) => b[1] - a[1])[0];
+      if (mostCommonFailure && mostCommonFailure[1] > 1) {
+        recommendations.push(`Address recurring issue: ${mostCommonFailure[0]}`);
+      }
+    }
+    const domains = new Set(experiences.map((e) => e.domain));
+    if (domains.has("shell")) {
+      recommendations.push("Verify command syntax and permissions");
+    }
+    if (domains.has("coding")) {
+      recommendations.push("Test thoroughly before deployment");
+    }
+    if (domains.has("network")) {
+      recommendations.push("Implement retry logic and error handling");
+    }
+    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...");
+    const experiencesToSave = Array.from(this.experiences.values());
+    let savedCount = 0;
+    for (const experience of experiencesToSave) {
+      await this.saveExperienceToMemory(experience);
+      savedCount++;
+    }
+    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 = {
+  name: "experience",
+  description: "Self-learning experience system that records and recalls transferable agent learnings",
+  actions: [recordExperienceAction],
+  services: [ExperienceService],
+  providers: [experienceProvider],
+  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}`);
+  }
+};
+var typescript_default = experiencePlugin;
+function parseOptionalNumber(value, fallback) {
+  if (!value)
+    return fallback;
+  const parsed = Number.parseFloat(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+export {
+  experiencePlugin,
+  typescript_default as default,
+  OutcomeType,
+  ExperienceType,
+  ExperienceServiceType,
+  ExperienceService
+};
+
+//# debugId=332CCD4C6A890DF464756E2164756E21