@elizaos/agent 0.25.9 → 2.0.0-alpha.151

package/packages/typescript/src/features/advanced-capabilities/experience/service.js

@@ -0,0 +1,569 @@
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../../../logger.js";
+import { ModelType } from "../../../types/model.js";
+import { Service } from "../../../types/service.js";
+import { ExperienceServiceType, ExperienceType, OutcomeType, } from "./types.js";
+import { ConfidenceDecayManager } from "./utils/confidenceDecay";
+import { ExperienceRelationshipManager } from "./utils/experienceRelationships";
+export 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();
+    dirtyExperiences = new Set();
+    persistTimer = null;
+    decayManager;
+    relationshipManager;
+    constructor(runtime) {
+        super(runtime);
+        this.decayManager = new ConfidenceDecayManager();
+        this.relationshipManager = new ExperienceRelationshipManager();
+        void this.loadExperiences();
+        // Batch-persist dirty access counts every 60 seconds
+        this.persistTimer = setInterval(() => {
+            void this.persistDirtyExperiences();
+        }, 60_000);
+    }
+    static async start(runtime) {
+        const service = new ExperienceService(runtime);
+        // loadExperiences is triggered in constructor
+        return service;
+    }
+    async loadExperiences() {
+        // Load experiences from the "experiences" table (same table we write to)
+        const memories = await this.runtime.getMemories({
+            entityId: this.runtime.agentId,
+            tableName: "experiences",
+        });
+        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 || ExperienceType.LEARNING,
+                    outcome: experienceData.outcome || OutcomeType.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),
+                    // Persisted memory rows keep the vector on the top-level Memory record.
+                    // Restoring it here preserves semantic recall across runtime restarts.
+                    embedding: Array.isArray(memory.embedding) && memory.embedding.length > 0
+                        ? memory.embedding
+                        : experienceData.embedding,
+                    relatedExperiences: experienceData.relatedExperiences,
+                    supersedes: experienceData.supersedes,
+                    previousBelief: experienceData.previousBelief,
+                    correctedBelief: experienceData.correctedBelief,
+                };
+                this.experiences.set(experience.id, experience);
+                // Update indexes
+                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);
+            }
+        }
+        logger.info(`[ExperienceService] Loaded ${this.experiences.size} experiences from memory`);
+    }
+    async recordExperience(experienceData) {
+        // Generate embedding for the experience (graceful fallback if unavailable)
+        const embeddingText = `${experienceData.context} ${experienceData.action} ${experienceData.result} ${experienceData.learning}`;
+        const runModel = this.runtime.useModel.bind(this.runtime);
+        let embedding;
+        try {
+            const result = await runModel(ModelType.TEXT_EMBEDDING, {
+                text: embeddingText,
+            });
+            // Validate the embedding is non-zero (some providers return zero vectors on error)
+            if (Array.isArray(result) &&
+                result.length > 0 &&
+                result.some((v) => v !== 0)) {
+                embedding = result;
+            }
+            else {
+                logger.warn("[ExperienceService] Embedding model returned empty/zero vector, storing without embedding");
+            }
+        }
+        catch (err) {
+            logger.warn(`[ExperienceService] Embedding generation failed, storing without embedding: ${err}`);
+        }
+        const now = Date.now();
+        const experience = {
+            id: uuidv4(),
+            agentId: this.runtime.agentId,
+            type: experienceData.type || ExperienceType.LEARNING,
+            outcome: experienceData.outcome || OutcomeType.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,
+        };
+        // Store the experience
+        this.experiences.set(experience.id, experience);
+        // Update indexes
+        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);
+        // Save to memory service
+        await this.saveExperienceToMemory(experience);
+        // Check for contradictions and add relationships
+        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,
+            });
+        }
+        logger.info(`[ExperienceService] Recorded experience: ${experience.id} (${experience.type})`);
+        return experience;
+    }
+    async saveExperienceToMemory(experience) {
+        const 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,
+        };
+        if (experience.lastAccessedAt !== undefined) {
+            data.lastAccessedAt = experience.lastAccessedAt;
+        }
+        if (experience.relatedExperiences !== undefined) {
+            data.relatedExperiences = experience.relatedExperiences;
+        }
+        if (experience.supersedes !== undefined) {
+            data.supersedes = experience.supersedes;
+        }
+        if (experience.previousBelief !== undefined) {
+            data.previousBelief = experience.previousBelief;
+        }
+        if (experience.correctedBelief !== undefined) {
+            data.correctedBelief = experience.correctedBelief;
+        }
+        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,
+            },
+            createdAt: experience.createdAt,
+        };
+        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 {
+                    // Re-mark as dirty so it retries next cycle
+                    this.dirtyExperiences.add(id);
+                }
+            }
+        }
+        if (saved > 0) {
+            logger.debug(`[ExperienceService] Persisted ${saved} dirty experiences`);
+        }
+    }
+    async queryExperiences(query) {
+        let results = [];
+        const limit = query.limit || 10;
+        if (query.query) {
+            // Semantic search path: over-fetch when filters will reduce the set
+            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 {
+            // Non-semantic path: filter then sort by quality
+            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, limit);
+        }
+        // Include related experiences if requested
+        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);
+        }
+        // Update access counts and mark dirty for batch persistence
+        for (const exp of results) {
+            exp.accessCount++;
+            exp.lastAccessedAt = Date.now();
+            this.dirtyExperiences.add(exp.id);
+        }
+        return results;
+    }
+    /** Apply query filters (type, outcome, domain, tags, confidence, importance, timeRange). */
+    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;
+    }
+    /**
+     * Find similar experiences using vector search + reranking.
+     *
+     * Reranking strategy:
+     *   Vector similarity is the dominant signal (70%) — an irrelevant experience
+     *   should never outrank a relevant one just because it has high confidence.
+     *   Quality signals (confidence, importance) act as tiebreakers among
+     *   similarly-relevant results (30% combined).
+     *
+     *   A minimum similarity threshold filters out noise so quality signals
+     *   can't promote genuinely irrelevant experiences.
+     */
+    async findSimilarExperiences(text, limit = 5) {
+        if (!text || this.experiences.size === 0) {
+            return [];
+        }
+        const runModel = this.runtime.useModel.bind(this.runtime);
+        let queryEmbedding;
+        try {
+            queryEmbedding = await runModel(ModelType.TEXT_EMBEDDING, {
+                text,
+            });
+            if (!Array.isArray(queryEmbedding) ||
+                queryEmbedding.length === 0 ||
+                queryEmbedding.every((v) => v === 0)) {
+                logger.warn("[ExperienceService] Query embedding is empty/zero, falling back to recency sort");
+                return this.fallbackSort(limit);
+            }
+        }
+        catch {
+            logger.warn("[ExperienceService] Query embedding failed, falling back to recency sort");
+            return this.fallbackSort(limit);
+        }
+        // Minimum cosine similarity to be considered a candidate at all.
+        // Prevents high-quality but irrelevant experiences from appearing.
+        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;
+            // --- Quality signals (all normalized 0-1) ---
+            // Confidence with time-decay applied
+            const decayedConfidence = this.decayManager.getDecayedConfidence(experience);
+            // Smooth recency: half-life of 30 days, never goes to zero
+            const ageDays = Math.max(0, (now - experience.createdAt) / (24 * 60 * 60 * 1000));
+            const recencyFactor = 1 / (1 + ageDays / 30);
+            // Access frequency: log-scaled, capped at 1.0
+            // ~0 at 0 accesses, ~0.33 at 1, ~0.66 at 3, ~1.0 at 9+
+            const accessFactor = Math.min(1, Math.log2(experience.accessCount + 1) / Math.log2(10));
+            // Weighted quality score (0-1 range)
+            const qualityScore = decayedConfidence * 0.45 +
+                experience.importance * 0.35 +
+                recencyFactor * 0.12 +
+                accessFactor * 0.08;
+            // Final reranking score: similarity dominates (70%), quality tiebreaks (30%)
+            const rerankScore = similarity * 0.7 + qualityScore * 0.3;
+            scored.push({ experience, score: rerankScore });
+        }
+        // Sort by combined reranking score (highest first)
+        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 = now;
+            this.dirtyExperiences.add(exp.id);
+        }
+        return results;
+    }
+    /** Fallback when embeddings are unavailable: sort by decayed confidence * importance. */
+    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,
+            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 === ExperienceType.CORRECTION && exp.correctedBelief) {
+                alternatives.add(exp.correctedBelief);
+            }
+            if (exp.outcome === OutcomeType.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 === OutcomeType.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 stop() {
+        logger.info("[ExperienceService] Stopping...");
+        // Stop the persistence timer
+        if (this.persistTimer) {
+            clearInterval(this.persistTimer);
+            this.persistTimer = null;
+        }
+        // Final persist of all dirty experiences + full save
+        const experiencesToSave = Array.from(this.experiences.values());
+        let savedCount = 0;
+        for (const experience of experiencesToSave) {
+            try {
+                await this.saveExperienceToMemory(experience);
+                savedCount++;
+            }
+            catch (err) {
+                logger.warn(`[ExperienceService] Failed to save experience ${experience.id}: ${err}`);
+            }
+        }
+        this.dirtyExperiences.clear();
+        logger.info(`[ExperienceService] Saved ${savedCount} experiences`);
+    }
+}

package/packages/typescript/src/features/advanced-capabilities/experience/types.d.ts

@@ -0,0 +1,95 @@
+import type { Memory } from "../../../types/memory.ts";
+import type { UUID } from "../../../types/primitives.ts";
+export type JsonPrimitive = string | number | boolean | null;
+export type JsonValue = JsonPrimitive | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+export type JsonObject = {
+    [key: string]: JsonValue;
+};
+declare module "../../../types/service.ts" {
+    interface ServiceTypeRegistry {
+        EXPERIENCE: "EXPERIENCE";
+    }
+}
+declare module "@elizaos/core" {
+    interface ServiceTypeRegistry {
+        EXPERIENCE: "EXPERIENCE";
+    }
+}
+export declare const ExperienceServiceType: {
+    EXPERIENCE: "EXPERIENCE";
+};
+export declare enum ExperienceType {
+    SUCCESS = "success",// Agent accomplished something
+    FAILURE = "failure",// Agent failed at something
+    DISCOVERY = "discovery",// Agent discovered new information
+    CORRECTION = "correction",// Agent corrected a mistake
+    LEARNING = "learning",// Agent learned something new
+    HYPOTHESIS = "hypothesis",// Agent formed a hypothesis
+    VALIDATION = "validation",// Agent validated a hypothesis
+    WARNING = "warning"
+}
+export declare enum OutcomeType {
+    POSITIVE = "positive",
+    NEGATIVE = "negative",
+    NEUTRAL = "neutral",
+    MIXED = "mixed"
+}
+export interface Experience {
+    id: UUID;
+    agentId: UUID;
+    type: ExperienceType;
+    outcome: OutcomeType;
+    context: string;
+    action: string;
+    result: string;
+    learning: string;
+    tags: string[];
+    domain: string;
+    relatedExperiences?: UUID[];
+    supersedes?: UUID;
+    confidence: number;
+    importance: number;
+    createdAt: number;
+    updatedAt: number;
+    lastAccessedAt?: number;
+    accessCount: number;
+    previousBelief?: string;
+    correctedBelief?: string;
+    embedding?: number[];
+    memoryIds?: UUID[];
+}
+export interface ExperienceQuery {
+    query?: string;
+    type?: ExperienceType | ExperienceType[];
+    outcome?: OutcomeType | OutcomeType[];
+    domain?: string | string[];
+    tags?: string[];
+    minImportance?: number;
+    minConfidence?: number;
+    timeRange?: {
+        start?: number;
+        end?: number;
+    };
+    limit?: number;
+    includeRelated?: boolean;
+}
+export interface ExperienceAnalysis {
+    pattern?: string;
+    frequency?: number;
+    reliability?: number;
+    alternatives?: string[];
+    recommendations?: string[];
+}
+export interface ExperienceEvent {
+    experienceId: UUID;
+    eventType: "created" | "accessed" | "updated" | "superseded";
+    timestamp: number;
+    metadata?: JsonObject;
+}
+export interface ExperienceMemory extends Memory {
+    experienceId: string;
+    experienceType: ExperienceType;
+}
+//# sourceMappingURL=types.d.ts.map

package/packages/typescript/src/features/advanced-capabilities/experience/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../../../../typescript/src/features/advanced-capabilities/experience/types.ts"],"names":[],"mappings":"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"}